Re-run yapf code, and pin version

src/python/grpcio/commands.py

@@ -205,9 +205,7 @@ def check_and_update_cythonization(extensions):
             base, file_ext = os.path.splitext(source)
             if file_ext == '.pyx':
                 generated_pyx_source = next((base + gen_ext
-                                             for gen_ext in (
+                                             for gen_ext in ('.c', '.cpp',)
-                                                 '.c',
-                                                 '.cpp',)
                                              if os.path.isfile(base + gen_ext)),
                                             None)
                 if generated_pyx_source:

src/python/grpcio/grpc/__init__.py

@@ -1297,47 +1297,22 @@ def server(thread_pool, handlers=None, options=None):
 
 ###################################  __all__  #################################
 
-__all__ = (
+__all__ = ('FutureTimeoutError', 'FutureCancelledError', 'Future',
-    'FutureTimeoutError',
+           'ChannelConnectivity', 'StatusCode', 'RpcError', 'RpcContext',
-    'FutureCancelledError',
+           'Call', 'ChannelCredentials', 'CallCredentials',
-    'Future',
+           'AuthMetadataContext', 'AuthMetadataPluginCallback',
-    'ChannelConnectivity',
+           'AuthMetadataPlugin', 'ServerCredentials', 'UnaryUnaryMultiCallable',
-    'StatusCode',
+           'UnaryStreamMultiCallable', 'StreamUnaryMultiCallable',
-    'RpcError',
+           'StreamStreamMultiCallable', 'Channel', 'ServicerContext',
-    'RpcContext',
+           'RpcMethodHandler', 'HandlerCallDetails', 'GenericRpcHandler',
-    'Call',
+           'ServiceRpcHandler', 'Server', 'unary_unary_rpc_method_handler',
-    'ChannelCredentials',
+           'unary_stream_rpc_method_handler', 'stream_unary_rpc_method_handler',
-    'CallCredentials',
-    'AuthMetadataContext',
-    'AuthMetadataPluginCallback',
-    'AuthMetadataPlugin',
-    'ServerCredentials',
-    'UnaryUnaryMultiCallable',
-    'UnaryStreamMultiCallable',
-    'StreamUnaryMultiCallable',
-    'StreamStreamMultiCallable',
-    'Channel',
-    'ServicerContext',
-    'RpcMethodHandler',
-    'HandlerCallDetails',
-    'GenericRpcHandler',
-    'ServiceRpcHandler',
-    'Server',
-    'unary_unary_rpc_method_handler',
-    'unary_stream_rpc_method_handler',
-    'stream_unary_rpc_method_handler',
            'stream_stream_rpc_method_handler',
-    'method_handlers_generic_handler',
+           'method_handlers_generic_handler', 'ssl_channel_credentials',
-    'ssl_channel_credentials',
+           'metadata_call_credentials', 'access_token_call_credentials',
-    'metadata_call_credentials',
+           'composite_call_credentials', 'composite_channel_credentials',
-    'access_token_call_credentials',
+           'ssl_server_credentials', 'channel_ready_future', 'insecure_channel',
-    'composite_call_credentials',
+           'secure_channel', 'server',)
-    'composite_channel_credentials',
-    'ssl_server_credentials',
-    'channel_ready_future',
-    'insecure_channel',
-    'secure_channel',
-    'server',)
 
 ############################### Extension Shims ################################
 

src/python/grpcio/grpc/_channel.py

@@ -45,26 +45,22 @@ _EMPTY_FLAGS = 0
 _INFINITE_FUTURE = cygrpc.Timespec(float('+inf'))
 _EMPTY_METADATA = cygrpc.Metadata(())
 
-_UNARY_UNARY_INITIAL_DUE = (
+_UNARY_UNARY_INITIAL_DUE = (cygrpc.OperationType.send_initial_metadata,
-    cygrpc.OperationType.send_initial_metadata,
                             cygrpc.OperationType.send_message,
                             cygrpc.OperationType.send_close_from_client,
                             cygrpc.OperationType.receive_initial_metadata,
                             cygrpc.OperationType.receive_message,
                             cygrpc.OperationType.receive_status_on_client,)
-_UNARY_STREAM_INITIAL_DUE = (
+_UNARY_STREAM_INITIAL_DUE = (cygrpc.OperationType.send_initial_metadata,
-    cygrpc.OperationType.send_initial_metadata,
                              cygrpc.OperationType.send_message,
                              cygrpc.OperationType.send_close_from_client,
                              cygrpc.OperationType.receive_initial_metadata,
                              cygrpc.OperationType.receive_status_on_client,)
-_STREAM_UNARY_INITIAL_DUE = (
+_STREAM_UNARY_INITIAL_DUE = (cygrpc.OperationType.send_initial_metadata,
-    cygrpc.OperationType.send_initial_metadata,
                              cygrpc.OperationType.receive_initial_metadata,
                              cygrpc.OperationType.receive_message,
                              cygrpc.OperationType.receive_status_on_client,)
-_STREAM_STREAM_INITIAL_DUE = (
+_STREAM_STREAM_INITIAL_DUE = (cygrpc.OperationType.send_initial_metadata,
-    cygrpc.OperationType.send_initial_metadata,
                               cygrpc.OperationType.receive_initial_metadata,
                               cygrpc.OperationType.receive_status_on_client,)
 
@@ -568,9 +564,9 @@ class _UnaryStreamMultiCallable(grpc.UnaryStreamMultiCallable):
                     )), event_handler)
                 operations = (
                     cygrpc.operation_send_initial_metadata(
-                        _common.cygrpc_metadata(metadata), _EMPTY_FLAGS),
+                        _common.cygrpc_metadata(metadata),
-                    cygrpc.operation_send_message(serialized_request,
+                        _EMPTY_FLAGS), cygrpc.operation_send_message(
-                                                  _EMPTY_FLAGS),
+                            serialized_request, _EMPTY_FLAGS),
                     cygrpc.operation_send_close_from_client(_EMPTY_FLAGS),
                     cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS),)
                 call_error = call.start_client_batch(
@@ -828,10 +824,7 @@ def _deliver(state, initial_connectivity, initial_callbacks):
 
 def _spawn_delivery(state, callbacks):
     delivering_thread = threading.Thread(
-        target=_deliver, args=(
+        target=_deliver, args=(state, state.connectivity, callbacks,))
-            state,
-            state.connectivity,
-            callbacks,))
     delivering_thread.start()
     state.delivering = True
 

src/python/grpcio/grpc/_common.py

@@ -40,12 +40,16 @@ from grpc._cython import cygrpc
 _EMPTY_METADATA = cygrpc.Metadata(())
 
 CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY = {
-    cygrpc.ConnectivityState.idle: grpc.ChannelConnectivity.IDLE,
+    cygrpc.ConnectivityState.idle:
-    cygrpc.ConnectivityState.connecting: grpc.ChannelConnectivity.CONNECTING,
+    grpc.ChannelConnectivity.IDLE,
-    cygrpc.ConnectivityState.ready: grpc.ChannelConnectivity.READY,
+    cygrpc.ConnectivityState.connecting:
+    grpc.ChannelConnectivity.CONNECTING,
+    cygrpc.ConnectivityState.ready:
+    grpc.ChannelConnectivity.READY,
     cygrpc.ConnectivityState.transient_failure:
     grpc.ChannelConnectivity.TRANSIENT_FAILURE,
-    cygrpc.ConnectivityState.shutdown: grpc.ChannelConnectivity.SHUTDOWN,
+    cygrpc.ConnectivityState.shutdown:
+    grpc.ChannelConnectivity.SHUTDOWN,
 }
 
 CYGRPC_STATUS_CODE_TO_STATUS_CODE = {

src/python/grpcio/grpc/_plugin_wrapping.py

@@ -37,8 +37,7 @@ from grpc._cython import cygrpc
 
 class AuthMetadataContext(
         collections.namedtuple('AuthMetadataContext', (
-            'service_url',
+            'service_url', 'method_name',)), grpc.AuthMetadataContext):
-            'method_name',)), grpc.AuthMetadataContext):
     pass
 
 

src/python/grpcio/grpc/_server.py

@@ -91,8 +91,7 @@ def _details(state):
 
 class _HandlerCallDetails(
         collections.namedtuple('_HandlerCallDetails', (
-            'method',
+            'method', 'invocation_metadata',)), grpc.HandlerCallDetails):
-            'invocation_metadata',)), grpc.HandlerCallDetails):
     pass
 
 
@@ -143,9 +142,8 @@ def _abort(state, call, code, details):
         effective_code = _abortion_code(state, code)
         effective_details = details if state.details is None else state.details
         if state.initial_metadata_allowed:
-            operations = (
+            operations = (cygrpc.operation_send_initial_metadata(
-                cygrpc.operation_send_initial_metadata(_EMPTY_METADATA,
+                _EMPTY_METADATA, _EMPTY_FLAGS),
-                                                       _EMPTY_FLAGS),
                           cygrpc.operation_send_status_from_server(
                               _common.cygrpc_metadata(state.trailing_metadata),
                               effective_code, effective_details, _EMPTY_FLAGS),)
@@ -417,9 +415,8 @@ def _send_response(rpc_event, state, serialized_response):
             return False
         else:
             if state.initial_metadata_allowed:
-                operations = (
+                operations = (cygrpc.operation_send_initial_metadata(
-                    cygrpc.operation_send_initial_metadata(_EMPTY_METADATA,
+                    _EMPTY_METADATA, _EMPTY_FLAGS),
-                                                           _EMPTY_FLAGS),
                               cygrpc.operation_send_message(serialized_response,
                                                             _EMPTY_FLAGS),)
                 state.initial_metadata_allowed = False
@@ -559,10 +556,8 @@ def _handle_unrecognized_method(rpc_event):
             _EMPTY_METADATA, cygrpc.StatusCode.unimplemented,
             b'Method not found!', _EMPTY_FLAGS),)
     rpc_state = _RPCState()
-    rpc_event.operation_call.start_server_batch(operations,
+    rpc_event.operation_call.start_server_batch(
-                                                lambda ignored_event: (
+        operations, lambda ignored_event: (rpc_state, (),))
-                                                    rpc_state,
-                                                    (),))
     return rpc_state
 
 

src/python/grpcio/grpc/_utilities.py

@@ -44,14 +44,9 @@ _DONE_CALLBACK_EXCEPTION_LOG_MESSAGE = (
 
 class RpcMethodHandler(
         collections.namedtuple('_RpcMethodHandler', (
-            'request_streaming',
+            'request_streaming', 'response_streaming', 'request_deserializer',
-            'response_streaming',
+            'response_serializer', 'unary_unary', 'unary_stream',
-            'request_deserializer',
+            'stream_unary', 'stream_stream',)), grpc.RpcMethodHandler):
-            'response_serializer',
-            'unary_unary',
-            'unary_stream',
-            'stream_unary',
-            'stream_stream',)), grpc.RpcMethodHandler):
     pass
 
 

src/python/grpcio/grpc/beta/_client_adaptations.py

@@ -454,11 +454,8 @@ class _GenericStub(face.GenericStub):
                              metadata=None,
                              with_call=None,
                              protocol_options=None):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _blocking_unary_unary(self._channel, group, method, timeout,
                                      with_call, protocol_options, metadata,
@@ -472,11 +469,8 @@ class _GenericStub(face.GenericStub):
                            timeout,
                            metadata=None,
                            protocol_options=None):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _future_unary_unary(self._channel, group, method, timeout,
                                    protocol_options, metadata,
@@ -490,11 +484,8 @@ class _GenericStub(face.GenericStub):
                             timeout,
                             metadata=None,
                             protocol_options=None):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _unary_stream(self._channel, group, method, timeout,
                              protocol_options, metadata,
@@ -509,11 +500,8 @@ class _GenericStub(face.GenericStub):
                               metadata=None,
                               with_call=None,
                               protocol_options=None):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _blocking_stream_unary(
             self._channel, group, method, timeout, with_call, protocol_options,
@@ -527,11 +515,8 @@ class _GenericStub(face.GenericStub):
                             timeout,
                             metadata=None,
                             protocol_options=None):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _future_stream_unary(
             self._channel, group, method, timeout, protocol_options, metadata,
@@ -545,11 +530,8 @@ class _GenericStub(face.GenericStub):
                              timeout,
                              metadata=None,
                              protocol_options=None):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _stream_stream(self._channel, group, method, timeout,
                               protocol_options, metadata,
@@ -599,44 +581,32 @@ class _GenericStub(face.GenericStub):
         raise NotImplementedError()
 
     def unary_unary(self, group, method):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _UnaryUnaryMultiCallable(
             self._channel, group, method, self._metadata_transformer,
             request_serializer, response_deserializer)
 
     def unary_stream(self, group, method):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _UnaryStreamMultiCallable(
             self._channel, group, method, self._metadata_transformer,
             request_serializer, response_deserializer)
 
     def stream_unary(self, group, method):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _StreamUnaryMultiCallable(
             self._channel, group, method, self._metadata_transformer,
             request_serializer, response_deserializer)
 
     def stream_stream(self, group, method):
-        request_serializer = self._request_serializers.get((
+        request_serializer = self._request_serializers.get((group, method,))
-            group,
+        response_deserializer = self._response_deserializers.get((group,
-            method,))
-        response_deserializer = self._response_deserializers.get((
-            group,
                                                                   method,))
         return _StreamStreamMultiCallable(
             self._channel, group, method, self._metadata_transformer,

src/python/grpcio/grpc/beta/_connectivity_channel.py

@@ -85,9 +85,7 @@ class ConnectivityChannel(object):
 
     def _spawn_delivery(self, connectivity, callbacks):
         delivering_thread = threading.Thread(
-            target=self._deliver, args=(
+            target=self._deliver, args=(connectivity, callbacks,))
-                connectivity,
-                callbacks,))
         delivering_thread.start()
         self._delivering = True
 

src/python/grpcio/grpc/beta/_server_adaptations.py

@@ -256,14 +256,9 @@ def _adapt_stream_stream_event(stream_stream_event):
 
 class _SimpleMethodHandler(
         collections.namedtuple('_MethodHandler', (
-            'request_streaming',
+            'request_streaming', 'response_streaming', 'request_deserializer',
-            'response_streaming',
+            'response_serializer', 'unary_unary', 'unary_stream',
-            'request_deserializer',
+            'stream_unary', 'stream_stream',)), grpc.RpcMethodHandler):
-            'response_serializer',
-            'unary_unary',
-            'unary_stream',
-            'stream_unary',
-            'stream_stream',)), grpc.RpcMethodHandler):
     pass
 
 

src/python/grpcio/grpc/framework/interfaces/base/utilities.py

@@ -34,19 +34,14 @@ from grpc.framework.interfaces.base import base
 
 
 class _Completion(base.Completion,
-                  collections.namedtuple('_Completion', (
+                  collections.namedtuple('_Completion', ('terminal_metadata',
-                      'terminal_metadata',
+                                                         'code', 'message',))):
-                      'code',
-                      'message',))):
     """A trivial implementation of base.Completion."""
 
 
 class _Subscription(base.Subscription,
                     collections.namedtuple('_Subscription', (
-                        'kind',
+                        'kind', 'termination_callback', 'allowance', 'operator',
-                        'termination_callback',
-                        'allowance',
-                        'operator',
                         'protocol_receiver',))):
     """A trivial implementation of base.Subscription."""
 

src/python/grpcio/grpc/framework/interfaces/face/face.py

@@ -63,18 +63,13 @@ class NoSuchMethodError(Exception):
         self.method = method
 
     def __repr__(self):
-        return 'face.NoSuchMethodError(%s, %s)' % (
+        return 'face.NoSuchMethodError(%s, %s)' % (self.group, self.method,)
-            self.group,
-            self.method,)
 
 
 class Abortion(
-        collections.namedtuple('Abortion', (
+        collections.namedtuple('Abortion',
-            'kind',
+                               ('kind', 'initial_metadata', 'terminal_metadata',
-            'initial_metadata',
+                                'code', 'details',))):
-            'terminal_metadata',
-            'code',
-            'details',))):
     """A value describing RPC abortion.
 
   Attributes:

src/python/grpcio/support.py

@@ -53,7 +53,9 @@ Could not find <Python.h>. This could mean the following:
     (check your environment variables or try re-installing?)
 """
 
-C_CHECKS = {C_PYTHON_DEV: C_PYTHON_DEV_ERROR_MESSAGE,}
+C_CHECKS = {
+    C_PYTHON_DEV: C_PYTHON_DEV_ERROR_MESSAGE,
+}
 
 
 def _compile(compiler, source_string):

src/python/grpcio_health_checking/setup.py

@@ -40,13 +40,14 @@ os.chdir(os.path.dirname(os.path.abspath(__file__)))
 import health_commands
 import grpc_version
 
-PACKAGE_DIRECTORIES = {'': '.',}
+PACKAGE_DIRECTORIES = {
+    '': '.',
+}
 
 SETUP_REQUIRES = (
     'grpcio-tools>={version}'.format(version=grpc_version.VERSION),)
 
-INSTALL_REQUIRES = (
+INSTALL_REQUIRES = ('protobuf>=3.0.0',
-    'protobuf>=3.0.0',
                     'grpcio>={version}'.format(version=grpc_version.VERSION),)
 
 COMMAND_CLASS = {

src/python/grpcio_reflection/setup.py

@@ -40,13 +40,14 @@ os.chdir(os.path.dirname(os.path.abspath(__file__)))
 import reflection_commands
 import grpc_version
 
-PACKAGE_DIRECTORIES = {'': '.',}
+PACKAGE_DIRECTORIES = {
+    '': '.',
+}
 
 SETUP_REQUIRES = (
     'grpcio-tools>={version}'.format(version=grpc_version.VERSION),)
 
-INSTALL_REQUIRES = (
+INSTALL_REQUIRES = ('protobuf>=3.0.0',
-    'protobuf>=3.0.0',
                     'grpcio>={version}'.format(version=grpc_version.VERSION),)
 
 COMMAND_CLASS = {

src/python/grpcio_tests/setup.py

@@ -47,18 +47,16 @@ import grpc_version
 
 LICENSE = '3-clause BSD'
 
-PACKAGE_DIRECTORIES = {'': '.',}
+PACKAGE_DIRECTORIES = {
+    '': '.',
+}
 
 INSTALL_REQUIRES = (
-    'coverage>=4.0',
+    'coverage>=4.0', 'enum34>=1.0.4', 'futures>=2.2.0',
-    'enum34>=1.0.4',
-    'futures>=2.2.0',
     'grpcio>={version}'.format(version=grpc_version.VERSION),
     'grpcio-tools>={version}'.format(version=grpc_version.VERSION),
     'grpcio-health-checking>={version}'.format(version=grpc_version.VERSION),
-    'oauth2client>=1.4.7',
+    'oauth2client>=1.4.7', 'protobuf>=3.0.0', 'six>=1.10',)
-    'protobuf>=3.0.0',
-    'six>=1.10',)
 
 COMMAND_CLASS = {
     # Run `preprocess` *before* doing any packaging!
@@ -75,7 +73,9 @@ PACKAGE_DATA = {
         'credentials/server1.key',
         'credentials/server1.pem',
     ],
-    'tests.protoc_plugin.protos.invocation_testing': ['same.proto',],
+    'tests.protoc_plugin.protos.invocation_testing': [
+        'same.proto',
+    ],
     'tests.protoc_plugin.protos.invocation_testing.split_messages': [
         'messages.proto',
     ],

src/python/grpcio_tests/tests/_result.py

@@ -453,7 +453,9 @@ def jenkins_junit_xml(result):
     })
     for case in result.cases.values():
         if case.kind is CaseResult.Kind.SUCCESS:
-            ElementTree.SubElement(suite, 'testcase', {'name': case.name,})
+            ElementTree.SubElement(suite, 'testcase', {
+                'name': case.name,
+            })
         elif case.kind in (CaseResult.Kind.ERROR, CaseResult.Kind.FAILURE):
             case_xml = ElementTree.SubElement(suite, 'testcase', {
                 'name': case.name,

src/python/grpcio_tests/tests/interop/_secure_intraop_test.py

@@ -55,8 +55,8 @@ class SecureIntraopTest(_intraop_test_case.IntraopTestCase, unittest.TestCase):
         self.stub = test_pb2.TestServiceStub(
             grpc.secure_channel('localhost:{}'.format(port),
                                 grpc.ssl_channel_credentials(
-                                    resources.test_root_certificates()), ((
+                                    resources.test_root_certificates()), (
-                                        'grpc.ssl_target_name_override',
+                                        ('grpc.ssl_target_name_override',
                                          _SERVER_HOST_OVERRIDE,),)))
 
 

src/python/grpcio_tests/tests/interop/client.py

@@ -116,9 +116,8 @@ def _stub(args):
             channel_credentials = grpc.composite_channel_credentials(
                 channel_credentials, call_credentials)
 
-        channel = grpc.secure_channel(target, channel_credentials, ((
+        channel = grpc.secure_channel(target, channel_credentials, (
-            'grpc.ssl_target_name_override',
+            ('grpc.ssl_target_name_override', args.server_host_override,),))
-            args.server_host_override,),))
     else:
         channel = grpc.insecure_channel(target)
     if args.test_case == "unimplemented_service":

src/python/grpcio_tests/tests/interop/methods.py

@@ -165,11 +165,7 @@ def _large_unary(stub):
 
 
 def _client_streaming(stub):
-    payload_body_sizes = (
+    payload_body_sizes = (27182, 8, 1828, 45904,)
-        27182,
-        8,
-        1828,
-        45904,)
     payloads = (messages_pb2.Payload(body=b'\x00' * size)
                 for size in payload_body_sizes)
     requests = (messages_pb2.StreamingInputCallRequest(payload=payload)
@@ -181,16 +177,11 @@ def _client_streaming(stub):
 
 
 def _server_streaming(stub):
-    sizes = (
+    sizes = (31415, 9, 2653, 58979,)
-        31415,
-        9,
-        2653,
-        58979,)
 
     request = messages_pb2.StreamingOutputCallRequest(
         response_type=messages_pb2.COMPRESSABLE,
-        response_parameters=(
+        response_parameters=(messages_pb2.ResponseParameters(size=sizes[0]),
-            messages_pb2.ResponseParameters(size=sizes[0]),
                              messages_pb2.ResponseParameters(size=sizes[1]),
                              messages_pb2.ResponseParameters(size=sizes[2]),
                              messages_pb2.ResponseParameters(size=sizes[3]),))
@@ -240,16 +231,8 @@ class _Pipe(object):
 
 
 def _ping_pong(stub):
-    request_response_sizes = (
+    request_response_sizes = (31415, 9, 2653, 58979,)
-        31415,
+    request_payload_sizes = (27182, 8, 1828, 45904,)
-        9,
-        2653,
-        58979,)
-    request_payload_sizes = (
-        27182,
-        8,
-        1828,
-        45904,)
 
     with _Pipe() as pipe:
         response_iterator = stub.FullDuplexCall(pipe)
@@ -277,16 +260,8 @@ def _cancel_after_begin(stub):
 
 
 def _cancel_after_first_response(stub):
-    request_response_sizes = (
+    request_response_sizes = (31415, 9, 2653, 58979,)
-        31415,
+    request_payload_sizes = (27182, 8, 1828, 45904,)
-        9,
-        2653,
-        58979,)
-    request_payload_sizes = (
-        27182,
-        8,
-        1828,
-        45904,)
     with _Pipe() as pipe:
         response_iterator = stub.FullDuplexCall(pipe)
 

src/python/grpcio_tests/tests/protoc_plugin/_python_plugin_test.py

@@ -134,9 +134,7 @@ class _ServicerMethods(object):
 
 
 class _Service(
-        collections.namedtuple('_Service', (
+        collections.namedtuple('_Service', ('servicer_methods', 'server',
-            'servicer_methods',
-            'server',
                                             'stub',))):
     """A live and running service.
 

src/python/grpcio_tests/tests/reflection/_reflection_servicer_test.py

@@ -69,8 +69,7 @@ class ReflectionServicerTest(unittest.TestCase):
         self._stub = reflection_pb2.ServerReflectionStub(channel)
 
     def testFileByName(self):
-        requests = (
+        requests = (reflection_pb2.ServerReflectionRequest(
-            reflection_pb2.ServerReflectionRequest(
             file_by_filename=_EMPTY_PROTO_FILE_NAME),
                     reflection_pb2.ServerReflectionRequest(
                         file_by_filename='i-donut-exist'),)
@@ -90,12 +89,10 @@ class ReflectionServicerTest(unittest.TestCase):
         self.assertSequenceEqual(expected_responses, responses)
 
     def testFileBySymbol(self):
-        requests = (
+        requests = (reflection_pb2.ServerReflectionRequest(
-            reflection_pb2.ServerReflectionRequest(
+            file_containing_symbol=_EMPTY_PROTO_SYMBOL_NAME
-                file_containing_symbol=_EMPTY_PROTO_SYMBOL_NAME),
+        ), reflection_pb2.ServerReflectionRequest(
-            reflection_pb2.ServerReflectionRequest(
+            file_containing_symbol='i.donut.exist.co.uk.org.net.me.name.foo'),)
-                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(
@@ -115,12 +112,11 @@ class ReflectionServicerTest(unittest.TestCase):
         'TODO(atash): implement file-containing-extension reflection '
         '(see https://github.com/google/protobuf/issues/2248)')
     def testFileContainingExtension(self):
-        requests = (
+        requests = (reflection_pb2.ServerReflectionRequest(
-            reflection_pb2.ServerReflectionRequest(
             file_containing_extension=reflection_pb2.ExtensionRequest(
                 containing_type='grpc.testing.proto2.Empty',
-                    extension_number=125,),),
+                extension_number=125,),
-            reflection_pb2.ServerReflectionRequest(
+        ), reflection_pb2.ServerReflectionRequest(
             file_containing_extension=reflection_pb2.ExtensionRequest(
                 containing_type='i.donut.exist.co.uk.org.net.me.name.foo',
                 extension_number=55,),),)
@@ -140,7 +136,8 @@ class ReflectionServicerTest(unittest.TestCase):
         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='',

src/python/grpcio_tests/tests/stress/client.py

@@ -117,8 +117,7 @@ def _get_channel(target, args):
             root_certificates = None  # will load default roots.
         channel_credentials = grpc.ssl_channel_credentials(
             root_certificates=root_certificates)
-        options = ((
+        options = (('grpc.ssl_target_name_override',
-            'grpc.ssl_target_name_override',
                     args.server_host_override,),)
         channel = grpc.secure_channel(
             target, channel_credentials, options=options)

src/python/grpcio_tests/tests/unit/_api_test.py

@@ -41,46 +41,23 @@ class AllTest(unittest.TestCase):
 
     def testAll(self):
         expected_grpc_code_elements = (
-            'FutureTimeoutError',
+            'FutureTimeoutError', 'FutureCancelledError', 'Future',
-            'FutureCancelledError',
+            'ChannelConnectivity', 'StatusCode', 'RpcError', 'RpcContext',
-            'Future',
+            'Call', 'ChannelCredentials', 'CallCredentials',
-            'ChannelConnectivity',
+            'AuthMetadataContext', 'AuthMetadataPluginCallback',
-            'StatusCode',
+            'AuthMetadataPlugin', 'ServerCredentials',
-            'RpcError',
+            'UnaryUnaryMultiCallable', 'UnaryStreamMultiCallable',
-            'RpcContext',
+            'StreamUnaryMultiCallable', 'StreamStreamMultiCallable', 'Channel',
-            'Call',
+            'ServicerContext', 'RpcMethodHandler', 'HandlerCallDetails',
-            'ChannelCredentials',
+            'GenericRpcHandler', 'ServiceRpcHandler', 'Server',
-            'CallCredentials',
+            'unary_unary_rpc_method_handler', 'unary_stream_rpc_method_handler',
-            'AuthMetadataContext',
-            'AuthMetadataPluginCallback',
-            'AuthMetadataPlugin',
-            'ServerCredentials',
-            'UnaryUnaryMultiCallable',
-            'UnaryStreamMultiCallable',
-            'StreamUnaryMultiCallable',
-            'StreamStreamMultiCallable',
-            'Channel',
-            'ServicerContext',
-            'RpcMethodHandler',
-            'HandlerCallDetails',
-            'GenericRpcHandler',
-            'ServiceRpcHandler',
-            'Server',
-            'unary_unary_rpc_method_handler',
-            'unary_stream_rpc_method_handler',
             'stream_unary_rpc_method_handler',
             'stream_stream_rpc_method_handler',
-            'method_handlers_generic_handler',
+            'method_handlers_generic_handler', 'ssl_channel_credentials',
-            'ssl_channel_credentials',
+            'metadata_call_credentials', 'access_token_call_credentials',
-            'metadata_call_credentials',
+            'composite_call_credentials', 'composite_channel_credentials',
-            'access_token_call_credentials',
+            'ssl_server_credentials', 'channel_ready_future',
-            'composite_call_credentials',
+            'insecure_channel', 'secure_channel', 'server',)
-            'composite_channel_credentials',
-            'ssl_server_credentials',
-            'channel_ready_future',
-            'insecure_channel',
-            'secure_channel',
-            'server',)
 
         six.assertCountEqual(self, expected_grpc_code_elements,
                              _from_grpc_import_star.GRPC_ELEMENTS)
@@ -89,9 +66,8 @@ class AllTest(unittest.TestCase):
 class ChannelConnectivityTest(unittest.TestCase):
 
     def testChannelConnectivity(self):
-        self.assertSequenceEqual((
+        self.assertSequenceEqual(
-            grpc.ChannelConnectivity.IDLE,
+            (grpc.ChannelConnectivity.IDLE, grpc.ChannelConnectivity.CONNECTING,
-            grpc.ChannelConnectivity.CONNECTING,
              grpc.ChannelConnectivity.READY,
              grpc.ChannelConnectivity.TRANSIENT_FAILURE,
              grpc.ChannelConnectivity.SHUTDOWN,),

src/python/grpcio_tests/tests/unit/_channel_args_test.py

@@ -39,12 +39,8 @@ class TestPointerWrapper(object):
         return 123456
 
 
-TEST_CHANNEL_ARGS = (
+TEST_CHANNEL_ARGS = (('arg1', b'bytes_val'), ('arg2', 'str_val'), ('arg3', 1),
-    ('arg1', b'bytes_val'),
+                     (b'arg4', 'str_val'), ('arg6', TestPointerWrapper()),)
-    ('arg2', 'str_val'),
-    ('arg3', 1),
-    (b'arg4', 'str_val'),
-    ('arg6', TestPointerWrapper()),)
 
 
 class ChannelArgsTest(unittest.TestCase):

src/python/grpcio_tests/tests/unit/_cython/_cancel_many_calls_test.py

@@ -167,10 +167,7 @@ class CancelManyCallsTest(unittest.TestCase):
 
         state = _State()
 
-        server_thread_args = (
+        server_thread_args = (state, server, server_completion_queue,
-            state,
-            server,
-            server_completion_queue,
                               server_thread_pool,)
         server_thread = threading.Thread(target=_serve, args=server_thread_args)
         server_thread.start()

src/python/grpcio_tests/tests/unit/_cython/_channel_test.py

@@ -71,9 +71,7 @@ class ChannelTest(unittest.TestCase):
 
     def test_single_channel_lonely_connectivity(self):
         channel, completion_queue = _channel_and_completion_queue()
-        _in_parallel(_connectivity_loop, (
+        _in_parallel(_connectivity_loop, (channel, completion_queue,))
-            channel,
-            completion_queue,))
         completion_queue.shutdown()
 
     def test_multiple_channels_lonely_connectivity(self):

src/python/grpcio_tests/tests/unit/_cython/_read_some_but_not_all_responses_test.py

@@ -151,11 +151,9 @@ 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_call_due = set(
-            server_send_initial_metadata_tag,
+            (server_send_initial_metadata_tag, server_send_first_message_tag,
-            server_send_first_message_tag,
+             server_send_second_message_tag, server_complete_rpc_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,

src/python/grpcio_tests/tests/unit/_invocation_defects_test.py

@@ -77,9 +77,7 @@ 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(((
+            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
-                'testkey',
-                'testvalue',),))
         return request
 
     def handle_unary_stream(self, request, servicer_context):
@@ -88,9 +86,7 @@ class _Handler(object):
             yield request
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata(((
+            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
-                'testkey',
-                'testvalue',),))
 
     def handle_stream_unary(self, request_iterator, servicer_context):
         if servicer_context is not None:
@@ -102,17 +98,13 @@ class _Handler(object):
             response_elements.append(request)
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata(((
+            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
-                '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(((
+            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
-                'testkey',
-                'testvalue',),))
         for request in request_iterator:
             self._control.control()
             yield request

src/python/grpcio_tests/tests/unit/_metadata_code_details_test.py

@@ -164,7 +164,8 @@ class _Servicer(object):
 
 def _generic_handler(servicer):
     method_handlers = {
-        _UNARY_UNARY: grpc.unary_unary_rpc_method_handler(
+        _UNARY_UNARY:
+        grpc.unary_unary_rpc_method_handler(
             servicer.unary_unary,
             request_deserializer=_REQUEST_DESERIALIZER,
             response_serializer=_RESPONSE_SERIALIZER),
@@ -172,7 +173,8 @@ def _generic_handler(servicer):
         grpc.unary_stream_rpc_method_handler(servicer.unary_stream),
         _STREAM_UNARY:
         grpc.stream_unary_rpc_method_handler(servicer.stream_unary),
-        _STREAM_STREAM: grpc.stream_stream_rpc_method_handler(
+        _STREAM_STREAM:
+        grpc.stream_stream_rpc_method_handler(
             servicer.stream_stream,
             request_deserializer=_REQUEST_DESERIALIZER,
             response_serializer=_RESPONSE_SERIALIZER),
@@ -192,25 +194,15 @@ class MetadataCodeDetailsTest(unittest.TestCase):
 
         channel = grpc.insecure_channel('localhost:{}'.format(port))
         self._unary_unary = channel.unary_unary(
-            '/'.join((
+            '/'.join(('', _SERVICE, _UNARY_UNARY,)),
-                '',
-                _SERVICE,
-                _UNARY_UNARY,)),
             request_serializer=_REQUEST_SERIALIZER,
             response_deserializer=_RESPONSE_DESERIALIZER,)
-        self._unary_stream = channel.unary_stream('/'.join((
+        self._unary_stream = channel.unary_stream(
-            '',
+            '/'.join(('', _SERVICE, _UNARY_STREAM,)),)
-            _SERVICE,
+        self._stream_unary = channel.stream_unary(
-            _UNARY_STREAM,)),)
+            '/'.join(('', _SERVICE, _STREAM_UNARY,)),)
-        self._stream_unary = channel.stream_unary('/'.join((
-            '',
-            _SERVICE,
-            _STREAM_UNARY,)),)
         self._stream_stream = channel.stream_stream(
-            '/'.join((
+            '/'.join(('', _SERVICE, _STREAM_STREAM,)),
-                '',
-                _SERVICE,
-                _STREAM_STREAM,)),
             request_serializer=_REQUEST_SERIALIZER,
             response_deserializer=_RESPONSE_DESERIALIZER,)
 

src/python/grpcio_tests/tests/unit/_rpc_test.py

@@ -78,9 +78,7 @@ 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(((
+            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
-                '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.
@@ -94,9 +92,7 @@ class _Handler(object):
             yield request
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata(((
+            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
-                'testkey',
-                'testvalue',),))
 
     def handle_stream_unary(self, request_iterator, servicer_context):
         if servicer_context is not None:
@@ -108,17 +104,13 @@ class _Handler(object):
             response_elements.append(request)
         self._control.control()
         if servicer_context is not None:
-            servicer_context.set_trailing_metadata(((
+            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
-                '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(((
+            servicer_context.set_trailing_metadata((('testkey', 'testvalue',),))
-                'testkey',
-                'testvalue',),))
         for request in request_iterator:
             self._control.control()
             yield request

src/python/grpcio_tests/tests/unit/beta/_beta_features_test.py

@@ -177,9 +177,9 @@ class BetaFeaturesTest(unittest.TestCase):
             thread_pool_size=test_constants.POOL_SIZE)
         self._server = implementations.server(
             method_implementations, options=server_options)
-        server_credentials = implementations.ssl_server_credentials([(
+        server_credentials = implementations.ssl_server_credentials([
-            resources.private_key(),
+            (resources.private_key(), resources.certificate_chain(),),
-            resources.certificate_chain(),),])
+        ])
         port = self._server.add_secure_port('[::]:0', server_credentials)
         self._server.start()
         self._channel_credentials = implementations.ssl_channel_credentials(
@@ -303,9 +303,9 @@ class ContextManagementAndLifecycleTest(unittest.TestCase):
 
         self._server_options = implementations.server_options(
             thread_pool_size=test_constants.POOL_SIZE)
-        self._server_credentials = implementations.ssl_server_credentials([(
+        self._server_credentials = implementations.ssl_server_credentials([
-            resources.private_key(),
+            (resources.private_key(), resources.certificate_chain(),),
-            resources.certificate_chain(),),])
+        ])
         self._channel_credentials = implementations.ssl_channel_credentials(
             resources.test_root_certificates())
         self._stub_options = implementations.stub_options(

src/python/grpcio_tests/tests/unit/beta/_face_interface_test.py

@@ -47,10 +47,8 @@ _SERVER_HOST_OVERRIDE = 'foo.test.google.fr'
 
 class _SerializationBehaviors(
         collections.namedtuple('_SerializationBehaviors', (
-            'request_serializers',
+            'request_serializers', 'request_deserializers',
-            'request_deserializers',
+            'response_serializers', 'response_deserializers',))):
-            'response_serializers',
-            'response_deserializers',))):
     pass
 
 
@@ -89,9 +87,9 @@ class _Implementation(test_interfaces.Implementation):
             thread_pool_size=test_constants.POOL_SIZE)
         server = implementations.server(
             method_implementations, options=server_options)
-        server_credentials = implementations.ssl_server_credentials([(
+        server_credentials = implementations.ssl_server_credentials([
-            resources.private_key(),
+            (resources.private_key(), resources.certificate_chain(),),
-            resources.certificate_chain(),),])
+        ])
         port = server.add_secure_port('[::]:0', server_credentials)
         server.start()
         channel_credentials = implementations.ssl_channel_credentials(

src/python/grpcio_tests/tests/unit/beta/test_utilities.py

@@ -48,7 +48,6 @@ def not_really_secure_channel(host, port, channel_credentials,
       conducted.
   """
     target = '%s:%d' % (host, port)
-    channel = grpc.secure_channel(target, channel_credentials, ((
+    channel = grpc.secure_channel(target, channel_credentials, (
-        'grpc.ssl_target_name_override',
+        ('grpc.ssl_target_name_override', server_host_override,),))
-        server_host_override,),))
     return implementations.Channel(channel)

src/python/grpcio_tests/tests/unit/framework/interfaces/face/_digest.py

@@ -49,12 +49,9 @@ _IDENTITY = lambda x: x
 
 class TestServiceDigest(
         collections.namedtuple('TestServiceDigest', (
-            'methods',
+            'methods', 'inline_method_implementations',
-            'inline_method_implementations',
+            'event_method_implementations', 'multi_method_implementation',
-            'event_method_implementations',
+            'unary_unary_messages_sequences', 'unary_stream_messages_sequences',
-            'multi_method_implementation',
-            'unary_unary_messages_sequences',
-            'unary_stream_messages_sequences',
             'stream_unary_messages_sequences',
             'stream_stream_messages_sequences',))):
     """A transformation of a service.TestService.

src/python/grpcio_tests/tests/unit/framework/interfaces/face/_invocation.py

@@ -206,7 +206,5 @@ def invoker_constructors():
   Returns:
     A sequence of InvokerConstructors.
   """
-    return (
+    return (_GenericInvokerConstructor(), _MultiCallableInvokerConstructor(),
-        _GenericInvokerConstructor(),
-        _MultiCallableInvokerConstructor(),
             _DynamicInvokerConstructor(),)

src/python/grpcio_tests/tests/unit/test_common.py

@@ -33,18 +33,9 @@ import collections
 import grpc
 import six
 
-INVOCATION_INITIAL_METADATA = (
+INVOCATION_INITIAL_METADATA = (('0', 'abc'), ('1', 'def'), ('2', 'ghi'),)
-    ('0', 'abc'),
+SERVICE_INITIAL_METADATA = (('3', 'jkl'), ('4', 'mno'), ('5', 'pqr'),)
-    ('1', 'def'),
+SERVICE_TERMINAL_METADATA = (('6', 'stu'), ('7', 'vwx'), ('8', 'yza'),)
-    ('2', 'ghi'),)
-SERVICE_INITIAL_METADATA = (
-    ('3', 'jkl'),
-    ('4', 'mno'),
-    ('5', 'pqr'),)
-SERVICE_TERMINAL_METADATA = (
-    ('6', 'stu'),
-    ('7', 'vwx'),
-    ('8', 'yza'),)
 DETAILS = 'test details'
 
 
@@ -103,7 +94,6 @@ 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, ((
+    channel = grpc.secure_channel(target, channel_credentials, (
-        'grpc.ssl_target_name_override',
+        ('grpc.ssl_target_name_override', server_host_override,),))
-        server_host_override,),))
     return channel

tools/distrib/yapf_code.sh

@@ -40,7 +40,8 @@ VIRTUALENV=python_format_venv
 
 virtualenv $VIRTUALENV
 PYTHON=`realpath $VIRTUALENV/bin/python`
-$PYTHON -m pip install --upgrade futures yapf
+$PYTHON -m pip install futures
+$PYTHON -m pip install yapf==0.16.0
 
 exclusion_args=""
 for exclusion in $EXCLUSIONS; do