Restoring authorship annotation for <heretic@yandex-team.ru>. Commit 2 of 2.

74 files changed, 8152 insertions, 8152 deletions

diff --git a/contrib/libs/grpc/src/python/grpcio/.yandex_meta/licenses.list.txt b/contrib/libs/grpc/src/python/grpcio/.yandex_meta/licenses.list.txt
index 920997b524..fa5b12c5a5 100644
--- a/contrib/libs/grpc/src/python/grpcio/.yandex_meta/licenses.list.txt
+++ b/contrib/libs/grpc/src/python/grpcio/.yandex_meta/licenses.list.txt
@@ -1,60 +1,60 @@
-====================Apache-2.0==================== 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
- 
- 
-====================COPYRIGHT==================== 
- * Copyright 2015 gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
- * Copyright 2015-2016 gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
- * Copyright 2016 gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
- * Copyright 2017 gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
- * Copyright 2018 gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
- * Copyright 2020 gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
-# Copyright 2019 The gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
-# Copyright 2019 gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
-# Copyright 2020 The gRPC authors. 
- 
- 
-====================COPYRIGHT==================== 
-// Copyright 2018 The gRPC Authors 
- 
- 
-====================COPYRIGHT==================== 
-// Copyright 2019 The gRPC Authors 
- 
- 
-====================COPYRIGHT==================== 
-// Copyright 2020 The gRPC Authors 
+====================Apache-2.0====================
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+====================COPYRIGHT====================
+ * Copyright 2015 gRPC authors.
+
+
+====================COPYRIGHT====================
+ * Copyright 2015-2016 gRPC authors.
+
+
+====================COPYRIGHT====================
+ * Copyright 2016 gRPC authors.
+
+
+====================COPYRIGHT====================
+ * Copyright 2017 gRPC authors.
+
+
+====================COPYRIGHT====================
+ * Copyright 2018 gRPC authors.
+
+
+====================COPYRIGHT====================
+ * Copyright 2020 gRPC authors.
+
+
+====================COPYRIGHT====================
+# Copyright 2019 The gRPC authors.
+
+
+====================COPYRIGHT====================
+# Copyright 2019 gRPC authors.
+
+
+====================COPYRIGHT====================
+# Copyright 2020 The gRPC authors.
+
+
+====================COPYRIGHT====================
+// Copyright 2018 The gRPC Authors
+
+
+====================COPYRIGHT====================
+// Copyright 2019 The gRPC Authors
+
+
+====================COPYRIGHT====================
+// Copyright 2020 The gRPC Authors
diff --git a/contrib/libs/grpc/src/python/grpcio/README.rst b/contrib/libs/grpc/src/python/grpcio/README.rst
index d251ad89cb..fe34ad5adf 100644
--- a/contrib/libs/grpc/src/python/grpcio/README.rst
+++ b/contrib/libs/grpc/src/python/grpcio/README.rst
@@ -55,7 +55,7 @@ package named :code:`python-dev`).
 ::
 
   $ export REPO_ROOT=grpc  # REPO_ROOT can be any directory of your choice
-  $ git clone -b RELEASE_TAG_HERE https://github.com/grpc/grpc $REPO_ROOT 
+  $ git clone -b RELEASE_TAG_HERE https://github.com/grpc/grpc $REPO_ROOT
   $ cd $REPO_ROOT
   $ git submodule update --init
 
diff --git a/contrib/libs/grpc/src/python/grpcio/_parallel_compile_patch.py b/contrib/libs/grpc/src/python/grpcio/_parallel_compile_patch.py
index 6422849d35..e4d50c3831 100644
--- a/contrib/libs/grpc/src/python/grpcio/_parallel_compile_patch.py
+++ b/contrib/libs/grpc/src/python/grpcio/_parallel_compile_patch.py
@@ -22,10 +22,10 @@ import os
 
 try:
     BUILD_EXT_COMPILER_JOBS = int(
-        os.environ['GRPC_PYTHON_BUILD_EXT_COMPILER_JOBS']) 
-except KeyError: 
-    import multiprocessing 
-    BUILD_EXT_COMPILER_JOBS = multiprocessing.cpu_count() 
+        os.environ['GRPC_PYTHON_BUILD_EXT_COMPILER_JOBS'])
+except KeyError:
+    import multiprocessing
+    BUILD_EXT_COMPILER_JOBS = multiprocessing.cpu_count()
 except ValueError:
     BUILD_EXT_COMPILER_JOBS = 1
 
diff --git a/contrib/libs/grpc/src/python/grpcio/commands.py b/contrib/libs/grpc/src/python/grpcio/commands.py
index fddf5bf58f..8240beb295 100644
--- a/contrib/libs/grpc/src/python/grpcio/commands.py
+++ b/contrib/libs/grpc/src/python/grpcio/commands.py
@@ -13,8 +13,8 @@
 # limitations under the License.
 """Provides distutils command classes for the GRPC Python setup process."""
 
-from __future__ import print_function 
- 
+from __future__ import print_function
+
 import distutils
 import glob
 import os
@@ -101,7 +101,7 @@ class SphinxDocumentation(setuptools.Command):
         target_dir = os.path.join(GRPC_STEM, 'doc', 'build')
         exit_code = sphinx.cmd.build.build_main(
             ['-b', 'html', '-W', '--keep-going', source_dir, target_dir])
-        if exit_code != 0: 
+        if exit_code != 0:
             raise CommandError(
                 "Documentation generation has warnings or errors")
 
@@ -151,10 +151,10 @@ def check_and_update_cythonization(extensions):
         for source in extension.sources:
             base, file_ext = os.path.splitext(source)
             if file_ext == '.pyx':
-                generated_pyx_source = next((base + gen_ext for gen_ext in ( 
-                    '.c', 
-                    '.cpp', 
-                ) if os.path.isfile(base + gen_ext)), None) 
+                generated_pyx_source = next((base + gen_ext for gen_ext in (
+                    '.c',
+                    '.cpp',
+                ) if os.path.isfile(base + gen_ext)), None)
                 if generated_pyx_source:
                     generated_pyx_sources.append(generated_pyx_source)
                 else:
@@ -196,7 +196,7 @@ def try_cythonize(extensions, linetracing=False, mandatory=True):
     return Cython.Build.cythonize(
         extensions,
         include_path=[
-            include_dir for extension in extensions 
+            include_dir for extension in extensions
             for include_dir in extension.include_dirs
         ] + [CYTHON_STEM],
         compiler_directives=cython_compiler_directives)
@@ -217,13 +217,13 @@ class BuildExt(build_ext.build_ext):
             """Test if default compiler is okay with specifying c++ version
             when invoked in C mode. GCC is okay with this, while clang is not.
             """
-            if platform.system() != 'Windows': 
-                return False 
+            if platform.system() != 'Windows':
+                return False
             # TODO(lidiz) Remove the generated a.out for success tests.
-            cc_test = subprocess.Popen(['cc', '-x', 'c', '-std=c++11', '-'], 
-                                       stdin=subprocess.PIPE, 
-                                       stdout=subprocess.PIPE, 
-                                       stderr=subprocess.PIPE) 
+            cc_test = subprocess.Popen(['cc', '-x', 'c', '-std=c++11', '-'],
+                                       stdin=subprocess.PIPE,
+                                       stdout=subprocess.PIPE,
+                                       stderr=subprocess.PIPE)
             _, cc_err = cc_test.communicate(input=b'int main(){return 0;}')
             return not 'invalid argument' in str(cc_err)
 
@@ -273,10 +273,10 @@ class Gather(setuptools.Command):
     """Command to gather project dependencies."""
 
     description = 'gather dependencies for grpcio'
-    user_options = [ 
-        ('test', 't', 'flag indicating to gather test dependencies'), 
-        ('install', 'i', 'flag indicating to gather install dependencies') 
-    ] 
+    user_options = [
+        ('test', 't', 'flag indicating to gather test dependencies'),
+        ('install', 'i', 'flag indicating to gather install dependencies')
+    ]
 
     def initialize_options(self):
         self.test = False
@@ -292,43 +292,43 @@ class Gather(setuptools.Command):
                 self.distribution.install_requires)
         if self.test and self.distribution.tests_require:
             self.distribution.fetch_build_eggs(self.distribution.tests_require)
- 
- 
-class Clean(setuptools.Command): 
-    """Command to clean build artifacts.""" 
- 
-    description = 'Clean build artifacts.' 
-    user_options = [ 
-        ('all', 'a', 'a phony flag to allow our script to continue'), 
-    ] 
- 
-    _FILE_PATTERNS = ( 
-        'python_build', 
-        'src/python/grpcio/__pycache__/', 
-        'src/python/grpcio/grpc/_cython/cygrpc.cpp', 
-        'src/python/grpcio/grpc/_cython/*.so', 
-        'src/python/grpcio/grpcio.egg-info/', 
-    ) 
-    _CURRENT_DIRECTORY = os.path.normpath( 
-        os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../..")) 
- 
-    def initialize_options(self): 
-        self.all = False 
- 
-    def finalize_options(self): 
-        pass 
- 
-    def run(self): 
-        for path_spec in self._FILE_PATTERNS: 
-            this_glob = os.path.normpath( 
-                os.path.join(Clean._CURRENT_DIRECTORY, path_spec)) 
-            abs_paths = glob.glob(this_glob) 
-            for path in abs_paths: 
-                if not str(path).startswith(Clean._CURRENT_DIRECTORY): 
-                    raise ValueError( 
-                        "Cowardly refusing to delete {}.".format(path)) 
-                print("Removing {}".format(os.path.relpath(path))) 
-                if os.path.isfile(path): 
-                    os.remove(str(path)) 
-                else: 
-                    shutil.rmtree(str(path)) 
+
+
+class Clean(setuptools.Command):
+    """Command to clean build artifacts."""
+
+    description = 'Clean build artifacts.'
+    user_options = [
+        ('all', 'a', 'a phony flag to allow our script to continue'),
+    ]
+
+    _FILE_PATTERNS = (
+        'python_build',
+        'src/python/grpcio/__pycache__/',
+        'src/python/grpcio/grpc/_cython/cygrpc.cpp',
+        'src/python/grpcio/grpc/_cython/*.so',
+        'src/python/grpcio/grpcio.egg-info/',
+    )
+    _CURRENT_DIRECTORY = os.path.normpath(
+        os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../.."))
+
+    def initialize_options(self):
+        self.all = False
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        for path_spec in self._FILE_PATTERNS:
+            this_glob = os.path.normpath(
+                os.path.join(Clean._CURRENT_DIRECTORY, path_spec))
+            abs_paths = glob.glob(this_glob)
+            for path in abs_paths:
+                if not str(path).startswith(Clean._CURRENT_DIRECTORY):
+                    raise ValueError(
+                        "Cowardly refusing to delete {}.".format(path))
+                print("Removing {}".format(os.path.relpath(path)))
+                if os.path.isfile(path):
+                    os.remove(str(path))
+                else:
+                    shutil.rmtree(str(path))
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/__init__.py b/contrib/libs/grpc/src/python/grpcio/grpc/__init__.py
index f36062d3f4..abe87458c4 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/__init__.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/__init__.py
@@ -187,7 +187,7 @@ class Future(six.with_metaclass(abc.ABCMeta)):
 
         The callback will be passed this Future object describing the outcome
         of the computation.  Callbacks will be invoked after the future is
-        terminated, whether successfully or not. 
+        terminated, whether successfully or not.
 
         If the computation has already completed, the callback will be called
         immediately.
@@ -414,8 +414,8 @@ class ClientCallDetails(six.with_metaclass(abc.ABCMeta)):
       metadata: Optional :term:`metadata` to be transmitted to
         the service-side of the RPC.
       credentials: An optional CallCredentials for the RPC.
-      wait_for_ready: This is an EXPERIMENTAL argument. An optional 
-            flag to enable :term:`wait_for_ready` mechanism. 
+      wait_for_ready: This is an EXPERIMENTAL argument. An optional
+            flag to enable :term:`wait_for_ready` mechanism.
       compression: An element of grpc.compression, e.g.
         grpc.compression.Gzip. This is an EXPERIMENTAL option.
     """
@@ -628,7 +628,7 @@ class AuthMetadataPlugin(six.with_metaclass(abc.ABCMeta)):
     def __call__(self, context, callback):
         """Implements authentication by passing metadata to a callback.
 
-        This method will be invoked asynchronously in a separate thread. 
+        This method will be invoked asynchronously in a separate thread.
 
         Args:
           context: An AuthMetadataContext providing information on the RPC that
@@ -690,7 +690,7 @@ class UnaryUnaryMultiCallable(six.with_metaclass(abc.ABCMeta)):
           credentials: An optional CallCredentials for the RPC. Only valid for
             secure Channel.
           wait_for_ready: This is an EXPERIMENTAL argument. An optional
-            flag to enable :term:`wait_for_ready` mechanism. 
+            flag to enable :term:`wait_for_ready` mechanism.
           compression: An element of grpc.compression, e.g.
             grpc.compression.Gzip. This is an EXPERIMENTAL option.
 
@@ -723,7 +723,7 @@ class UnaryUnaryMultiCallable(six.with_metaclass(abc.ABCMeta)):
           credentials: An optional CallCredentials for the RPC. Only valid for
             secure Channel.
           wait_for_ready: This is an EXPERIMENTAL argument. An optional
-            flag to enable :term:`wait_for_ready` mechanism. 
+            flag to enable :term:`wait_for_ready` mechanism.
           compression: An element of grpc.compression, e.g.
             grpc.compression.Gzip. This is an EXPERIMENTAL option.
 
@@ -756,7 +756,7 @@ class UnaryUnaryMultiCallable(six.with_metaclass(abc.ABCMeta)):
           credentials: An optional CallCredentials for the RPC. Only valid for
             secure Channel.
           wait_for_ready: This is an EXPERIMENTAL argument. An optional
-            flag to enable :term:`wait_for_ready` mechanism. 
+            flag to enable :term:`wait_for_ready` mechanism.
           compression: An element of grpc.compression, e.g.
             grpc.compression.Gzip. This is an EXPERIMENTAL option.
 
@@ -792,7 +792,7 @@ class UnaryStreamMultiCallable(six.with_metaclass(abc.ABCMeta)):
           credentials: An optional CallCredentials for the RPC. Only valid for
             secure Channel.
           wait_for_ready: This is an EXPERIMENTAL argument. An optional
-            flag to enable :term:`wait_for_ready` mechanism. 
+            flag to enable :term:`wait_for_ready` mechanism.
           compression: An element of grpc.compression, e.g.
             grpc.compression.Gzip. This is an EXPERIMENTAL option.
 
@@ -828,7 +828,7 @@ class StreamUnaryMultiCallable(six.with_metaclass(abc.ABCMeta)):
           credentials: An optional CallCredentials for the RPC. Only valid for
             secure Channel.
           wait_for_ready: This is an EXPERIMENTAL argument. An optional
-            flag to enable :term:`wait_for_ready` mechanism. 
+            flag to enable :term:`wait_for_ready` mechanism.
           compression: An element of grpc.compression, e.g.
             grpc.compression.Gzip. This is an EXPERIMENTAL option.
 
@@ -862,7 +862,7 @@ class StreamUnaryMultiCallable(six.with_metaclass(abc.ABCMeta)):
           credentials: An optional CallCredentials for the RPC. Only valid for
             secure Channel.
           wait_for_ready: This is an EXPERIMENTAL argument. An optional
-            flag to enable :term:`wait_for_ready` mechanism. 
+            flag to enable :term:`wait_for_ready` mechanism.
           compression: An element of grpc.compression, e.g.
             grpc.compression.Gzip. This is an EXPERIMENTAL option.
 
@@ -895,7 +895,7 @@ class StreamUnaryMultiCallable(six.with_metaclass(abc.ABCMeta)):
           credentials: An optional CallCredentials for the RPC. Only valid for
             secure Channel.
           wait_for_ready: This is an EXPERIMENTAL argument. An optional
-            flag to enable :term:`wait_for_ready` mechanism. 
+            flag to enable :term:`wait_for_ready` mechanism.
           compression: An element of grpc.compression, e.g.
             grpc.compression.Gzip. This is an EXPERIMENTAL option.
 
@@ -931,7 +931,7 @@ class StreamStreamMultiCallable(six.with_metaclass(abc.ABCMeta)):
           credentials: An optional CallCredentials for the RPC. Only valid for
             secure Channel.
           wait_for_ready: This is an EXPERIMENTAL argument. An optional
-            flag to enable :term:`wait_for_ready` mechanism. 
+            flag to enable :term:`wait_for_ready` mechanism.
           compression: An element of grpc.compression, e.g.
             grpc.compression.Gzip. This is an EXPERIMENTAL option.
 
@@ -994,9 +994,9 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional :term:`serializer` for serializing the request 
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional :term:`deserializer` for deserializing the 
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None
             is passed.
 
@@ -1014,9 +1014,9 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional :term:`serializer` for serializing the request 
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional :term:`deserializer` for deserializing the 
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None is
             passed.
 
@@ -1034,9 +1034,9 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional :term:`serializer` for serializing the request 
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional :term:`deserializer` for deserializing the 
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None is
             passed.
 
@@ -1054,9 +1054,9 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
 
         Args:
           method: The name of the RPC method.
-          request_serializer: Optional :term:`serializer` for serializing the request 
+          request_serializer: Optional :term:`serializer` for serializing the request
             message. Request goes unserialized in case None is passed.
-          response_deserializer: Optional :term:`deserializer` for deserializing the 
+          response_deserializer: Optional :term:`deserializer` for deserializing the
             response message. Response goes undeserialized in case None
             is passed.
 
@@ -1076,15 +1076,15 @@ class Channel(six.with_metaclass(abc.ABCMeta)):
         """
         raise NotImplementedError()
 
-    def __enter__(self): 
-        """Enters the runtime context related to the channel object.""" 
-        raise NotImplementedError() 
+    def __enter__(self):
+        """Enters the runtime context related to the channel object."""
+        raise NotImplementedError()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exits the runtime context related to the channel object."""
+        raise NotImplementedError()
+
 
-    def __exit__(self, exc_type, exc_val, exc_tb): 
-        """Exits the runtime context related to the channel object.""" 
-        raise NotImplementedError() 
- 
- 
 ##########################  Service-Side Context  ##############################
 
 
@@ -1170,14 +1170,14 @@ class ServicerContext(six.with_metaclass(abc.ABCMeta, RpcContext)):
 
     @abc.abstractmethod
     def set_trailing_metadata(self, trailing_metadata):
-        """Sets the trailing metadata for the RPC. 
-
-        Sets the trailing metadata to be sent upon completion of the RPC. 
- 
-        If this method is invoked multiple times throughout the lifetime of an 
-        RPC, the value supplied in the final invocation will be the value sent 
-        over the wire. 
- 
+        """Sets the trailing metadata for the RPC.
+
+        Sets the trailing metadata to be sent upon completion of the RPC.
+
+        If this method is invoked multiple times throughout the lifetime of an
+        RPC, the value supplied in the final invocation will be the value sent
+        over the wire.
+
         This method need not be called by implementations if they have no
         metadata to add to what the gRPC runtime will transmit.
 
@@ -1271,11 +1271,11 @@ class RpcMethodHandler(six.with_metaclass(abc.ABCMeta)):
         or any arbitrary number of request messages.
       response_streaming: Whether the RPC supports exactly one response message
         or any arbitrary number of response messages.
-      request_deserializer: A callable :term:`deserializer` that accepts a byte string and 
+      request_deserializer: A callable :term:`deserializer` that accepts a byte string and
         returns an object suitable to be passed to this object's business
         logic, or None to indicate that this object's business logic should be
         passed the raw request bytes.
-      response_serializer: A callable :term:`serializer` that accepts an object produced 
+      response_serializer: A callable :term:`serializer` that accepts an object produced
         by this object's business logic and returns a byte string, or None to
         indicate that the byte strings produced by this object's business logic
         should be transmitted on the wire as they are.
@@ -1496,8 +1496,8 @@ def unary_unary_rpc_method_handler(behavior,
     Args:
       behavior: The implementation of an RPC that accepts one request
         and returns one response.
-      request_deserializer: An optional :term:`deserializer` for request deserialization. 
-      response_serializer: An optional :term:`serializer` for response serialization. 
+      request_deserializer: An optional :term:`deserializer` for request deserialization.
+      response_serializer: An optional :term:`serializer` for response serialization.
 
     Returns:
       An RpcMethodHandler object that is typically used by grpc.Server.
@@ -1516,8 +1516,8 @@ def unary_stream_rpc_method_handler(behavior,
     Args:
       behavior: The implementation of an RPC that accepts one request
         and returns an iterator of response values.
-      request_deserializer: An optional :term:`deserializer` for request deserialization. 
-      response_serializer: An optional :term:`serializer` for response serialization. 
+      request_deserializer: An optional :term:`deserializer` for request deserialization.
+      response_serializer: An optional :term:`serializer` for response serialization.
 
     Returns:
       An RpcMethodHandler object that is typically used by grpc.Server.
@@ -1536,8 +1536,8 @@ def stream_unary_rpc_method_handler(behavior,
     Args:
       behavior: The implementation of an RPC that accepts an iterator of
         request values and returns a single response value.
-      request_deserializer: An optional :term:`deserializer` for request deserialization. 
-      response_serializer: An optional :term:`serializer` for response serialization. 
+      request_deserializer: An optional :term:`deserializer` for request deserialization.
+      response_serializer: An optional :term:`serializer` for response serialization.
 
     Returns:
       An RpcMethodHandler object that is typically used by grpc.Server.
@@ -1556,8 +1556,8 @@ def stream_stream_rpc_method_handler(behavior,
     Args:
       behavior: The implementation of an RPC that accepts an iterator of
         request values and returns an iterator of response values.
-      request_deserializer: An optional :term:`deserializer` for request deserialization. 
-      response_serializer: An optional :term:`serializer` for response serialization. 
+      request_deserializer: An optional :term:`deserializer` for request deserialization.
+      response_serializer: An optional :term:`serializer` for response serialization.
 
     Returns:
       An RpcMethodHandler object that is typically used by grpc.Server.
@@ -1597,7 +1597,7 @@ def ssl_channel_credentials(root_certificates=None,
       private_key: The PEM-encoded private key as a byte string, or None if no
         private key should be used.
       certificate_chain: The PEM-encoded certificate chain as a byte string
-        to use or None if no certificate chain should be used. 
+        to use or None if no certificate chain should be used.
 
     Returns:
       A ChannelCredentials for use with an SSL-enabled Channel.
@@ -1833,58 +1833,58 @@ def local_server_credentials(local_connect_type=LocalConnectionType.LOCAL_TCP):
         _cygrpc.server_credentials_local(local_connect_type.value))
 
 
-def alts_channel_credentials(service_accounts=None): 
-    """Creates a ChannelCredentials for use with an ALTS-enabled Channel. 
- 
-    This is an EXPERIMENTAL API. 
-    ALTS credentials API can only be used in GCP environment as it relies on 
-    handshaker service being available. For more info about ALTS see 
-    https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security 
- 
-    Args: 
-      service_accounts: A list of server identities accepted by the client. 
-        If target service accounts are provided and none of them matches the 
-        peer identity of the server, handshake will fail. The arg can be empty 
-        if the client does not have any information about trusted server 
-        identity. 
-    Returns: 
-      A ChannelCredentials for use with an ALTS-enabled Channel 
-    """ 
-    return ChannelCredentials( 
-        _cygrpc.channel_credentials_alts(service_accounts or [])) 
- 
- 
-def alts_server_credentials(): 
-    """Creates a ServerCredentials for use with an ALTS-enabled connection. 
- 
-    This is an EXPERIMENTAL API. 
-    ALTS credentials API can only be used in GCP environment as it relies on 
-    handshaker service being available. For more info about ALTS see 
-    https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security 
- 
-    Returns: 
-      A ServerCredentials for use with an ALTS-enabled Server 
-    """ 
-    return ServerCredentials(_cygrpc.server_credentials_alts()) 
- 
- 
-def compute_engine_channel_credentials(call_credentials): 
-    """Creates a compute engine channel credential. 
- 
-    This credential can only be used in a GCP environment as it relies on 
-    a handshaker service. For more info about ALTS, see 
-    https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security 
- 
-    This channel credential is expected to be used as part of a composite 
-    credential in conjunction with a call credentials that authenticates the 
-    VM's default service account. If used with any other sort of call 
-    credential, the connection may suddenly and unexpectedly begin failing RPCs. 
-    """ 
-    return ChannelCredentials( 
-        _cygrpc.channel_credentials_compute_engine( 
-            call_credentials._credentials)) 
- 
- 
+def alts_channel_credentials(service_accounts=None):
+    """Creates a ChannelCredentials for use with an ALTS-enabled Channel.
+
+    This is an EXPERIMENTAL API.
+    ALTS credentials API can only be used in GCP environment as it relies on
+    handshaker service being available. For more info about ALTS see
+    https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security
+
+    Args:
+      service_accounts: A list of server identities accepted by the client.
+        If target service accounts are provided and none of them matches the
+        peer identity of the server, handshake will fail. The arg can be empty
+        if the client does not have any information about trusted server
+        identity.
+    Returns:
+      A ChannelCredentials for use with an ALTS-enabled Channel
+    """
+    return ChannelCredentials(
+        _cygrpc.channel_credentials_alts(service_accounts or []))
+
+
+def alts_server_credentials():
+    """Creates a ServerCredentials for use with an ALTS-enabled connection.
+
+    This is an EXPERIMENTAL API.
+    ALTS credentials API can only be used in GCP environment as it relies on
+    handshaker service being available. For more info about ALTS see
+    https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security
+
+    Returns:
+      A ServerCredentials for use with an ALTS-enabled Server
+    """
+    return ServerCredentials(_cygrpc.server_credentials_alts())
+
+
+def compute_engine_channel_credentials(call_credentials):
+    """Creates a compute engine channel credential.
+
+    This credential can only be used in a GCP environment as it relies on
+    a handshaker service. For more info about ALTS, see
+    https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security
+
+    This channel credential is expected to be used as part of a composite
+    credential in conjunction with a call credentials that authenticates the
+    VM's default service account. If used with any other sort of call
+    credential, the connection may suddenly and unexpectedly begin failing RPCs.
+    """
+    return ChannelCredentials(
+        _cygrpc.channel_credentials_compute_engine(
+            call_credentials._credentials))
+
+
 def channel_ready_future(channel):
     """Creates a Future that tracks when a Channel is ready.
 
@@ -1909,7 +1909,7 @@ def insecure_channel(target, options=None, compression=None):
 
     Args:
       target: The server address
-      options: An optional list of key-value pairs (:term:`channel_arguments` 
+      options: An optional list of key-value pairs (:term:`channel_arguments`
         in gRPC Core runtime) to configure the channel.
       compression: An optional value indicating the compression method to be
         used over the lifetime of the channel. This is an EXPERIMENTAL option.
@@ -1918,8 +1918,8 @@ def insecure_channel(target, options=None, compression=None):
       A Channel.
     """
     from grpc import _channel  # pylint: disable=cyclic-import
-    return _channel.Channel(target, () if options is None else options, None, 
-                            compression) 
+    return _channel.Channel(target, () if options is None else options, None,
+                            compression)
 
 
 def secure_channel(target, credentials, options=None, compression=None):
@@ -1930,7 +1930,7 @@ def secure_channel(target, credentials, options=None, compression=None):
     Args:
       target: The server address.
       credentials: A ChannelCredentials instance.
-      options: An optional list of key-value pairs (:term:`channel_arguments` 
+      options: An optional list of key-value pairs (:term:`channel_arguments`
         in gRPC Core runtime) to configure the channel.
       compression: An optional value indicating the compression method to be
         used over the lifetime of the channel. This is an EXPERIMENTAL option.
@@ -1939,11 +1939,11 @@ def secure_channel(target, credentials, options=None, compression=None):
       A Channel.
     """
     from grpc import _channel  # pylint: disable=cyclic-import
-    from grpc.experimental import _insecure_channel_credentials 
-    if credentials._credentials is _insecure_channel_credentials: 
-        raise ValueError( 
-            "secure_channel cannot be called with insecure credentials." + 
-            " Call insecure_channel instead.") 
+    from grpc.experimental import _insecure_channel_credentials
+    if credentials._credentials is _insecure_channel_credentials:
+        raise ValueError(
+            "secure_channel cannot be called with insecure credentials." +
+            " Call insecure_channel instead.")
     return _channel.Channel(target, () if options is None else options,
                             credentials._credentials, compression)
 
@@ -1994,7 +1994,7 @@ def server(thread_pool,
         and optionally manipulate the incoming RPCs before handing them over to
         handlers. The interceptors are given control in the order they are
         specified. This is an EXPERIMENTAL API.
-      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC runtime) 
+      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC runtime)
         to configure the channel.
       maximum_concurrent_rpcs: The maximum number of concurrent RPCs this server
         will service before returning RESOURCE_EXHAUSTED status, or None to
@@ -2007,10 +2007,10 @@ def server(thread_pool,
       A Server object.
     """
     from grpc import _server  # pylint: disable=cyclic-import
-    return _server.create_server(thread_pool, 
-                                 () if handlers is None else handlers, 
-                                 () if interceptors is None else interceptors, 
-                                 () if options is None else options, 
+    return _server.create_server(thread_pool,
+                                 () if handlers is None else handlers,
+                                 () if interceptors is None else interceptors,
+                                 () if options is None else options,
                                  maximum_concurrent_rpcs, compression)
 
 
@@ -2038,8 +2038,8 @@ class Compression(enum.IntEnum):
     Gzip = _compression.Gzip
 
 
-from grpc._runtime_protos import protos, services, protos_and_services  # pylint: disable=wrong-import-position 
- 
+from grpc._runtime_protos import protos, services, protos_and_services  # pylint: disable=wrong-import-position
+
 ###################################  __all__  #################################
 
 __all__ = (
@@ -2090,8 +2090,8 @@ __all__ = (
     'composite_channel_credentials',
     'local_channel_credentials',
     'local_server_credentials',
-    'alts_channel_credentials', 
-    'alts_server_credentials', 
+    'alts_channel_credentials',
+    'alts_server_credentials',
     'ssl_server_credentials',
     'ssl_server_certificate_configuration',
     'dynamic_ssl_server_credentials',
@@ -2100,9 +2100,9 @@ __all__ = (
     'secure_channel',
     'intercept_channel',
     'server',
-    'protos', 
-    'services', 
-    'protos_and_services', 
+    'protos',
+    'services',
+    'protos_and_services',
 )
 
 ############################### Extension Shims ################################
@@ -2123,8 +2123,8 @@ try:
     sys.modules.update({'grpc.reflection': grpc_reflection})
 except ImportError:
     pass
- 
-# Prevents import order issue in the case of renamed path. 
-if sys.version_info >= (3, 6) and __name__ == "grpc": 
-    from grpc import aio  # pylint: disable=ungrouped-imports 
-    sys.modules.update({'grpc.aio': aio}) 
+
+# Prevents import order issue in the case of renamed path.
+if sys.version_info >= (3, 6) and __name__ == "grpc":
+    from grpc import aio  # pylint: disable=ungrouped-imports
+    sys.modules.update({'grpc.aio': aio})
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_auth.py b/contrib/libs/grpc/src/python/grpcio/grpc/_auth.py
index 298943ff78..2d38320aff 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_auth.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_auth.py
@@ -34,18 +34,18 @@ class GoogleCallCredentials(grpc.AuthMetadataPlugin):
             credentials.get_access_token).args
 
     def __call__(self, context, callback):
-        try: 
-            if self._is_jwt: 
-                access_token = self._credentials.get_access_token( 
-                    additional_claims={ 
-                        'aud': context.service_url 
-                    }).access_token 
-            else: 
-                access_token = self._credentials.get_access_token().access_token 
-        except Exception as exception:  # pylint: disable=broad-except 
-            _sign_request(callback, None, exception) 
+        try:
+            if self._is_jwt:
+                access_token = self._credentials.get_access_token(
+                    additional_claims={
+                        'aud': context.service_url
+                    }).access_token
+            else:
+                access_token = self._credentials.get_access_token().access_token
+        except Exception as exception:  # pylint: disable=broad-except
+            _sign_request(callback, None, exception)
         else:
-            _sign_request(callback, access_token, None) 
+            _sign_request(callback, access_token, None)
 
 
 class AccessTokenAuthMetadataPlugin(grpc.AuthMetadataPlugin):
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_channel.py b/contrib/libs/grpc/src/python/grpcio/grpc/_channel.py
index 530fa905bc..11921d7883 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_channel.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_channel.py
@@ -172,8 +172,8 @@ def _event_handler(state, response_deserializer):
             except Exception as e:  # pylint: disable=broad-except
                 # NOTE(rbellevi): We suppress but log errors here so as not to
                 # kill the channel spin thread.
-                logging.error('Exception in callback %s: %s', 
-                              repr(callback.func), repr(e)) 
+                logging.error('Exception in callback %s: %s',
+                              repr(callback.func), repr(e))
         return done and state.fork_epoch >= cygrpc.get_fork_epoch()
 
     return handle_event
@@ -233,11 +233,11 @@ def _consume_request_iterator(request_iterator, state, call, request_serializer,
                                     cygrpc.OperationType.send_message not in
                                     state.due)
 
-                        _common.wait(state.condition.wait, 
-                                     _done, 
-                                     spin_cb=functools.partial( 
-                                         cygrpc.block_if_fork_in_progress, 
-                                         state)) 
+                        _common.wait(state.condition.wait,
+                                     _done,
+                                     spin_cb=functools.partial(
+                                         cygrpc.block_if_fork_in_progress,
+                                         state))
                         if state.code is not None:
                             return
                 else:
@@ -442,112 +442,112 @@ class _Rendezvous(grpc.RpcError, grpc.RpcContext):
                 self._state.condition.notify_all()
 
 
-class _SingleThreadedRendezvous(_Rendezvous, grpc.Call, grpc.Future):  # pylint: disable=too-many-ancestors 
+class _SingleThreadedRendezvous(_Rendezvous, grpc.Call, grpc.Future):  # pylint: disable=too-many-ancestors
     """An RPC iterator operating entirely on a single thread.
 
     The __next__ method of _SingleThreadedRendezvous does not depend on the
     existence of any other thread, including the "channel spin thread".
     However, this means that its interface is entirely synchronous. So this
-    class cannot completely fulfill the grpc.Future interface. The result, 
-    exception, and traceback methods will never block and will instead raise 
-    an exception if calling the method would result in blocking. 
- 
-    This means that these methods are safe to call from add_done_callback 
-    handlers. 
+    class cannot completely fulfill the grpc.Future interface. The result,
+    exception, and traceback methods will never block and will instead raise
+    an exception if calling the method would result in blocking.
+
+    This means that these methods are safe to call from add_done_callback
+    handlers.
     """
 
-    def _is_complete(self): 
-        return self._state.code is not None 
- 
-    def cancelled(self): 
-        with self._state.condition: 
-            return self._state.cancelled 
- 
-    def running(self): 
-        with self._state.condition: 
-            return self._state.code is None 
- 
-    def done(self): 
-        with self._state.condition: 
-            return self._state.code is not None 
- 
-    def result(self, timeout=None): 
-        """Returns the result of the computation or raises its exception. 
- 
-        This method will never block. Instead, it will raise an exception 
-        if calling this method would otherwise result in blocking. 
- 
-        Since this method will never block, any `timeout` argument passed will 
-        be ignored. 
-        """ 
-        del timeout 
-        with self._state.condition: 
-            if not self._is_complete(): 
-                raise grpc.experimental.UsageError( 
-                    "_SingleThreadedRendezvous only supports result() when the RPC is complete." 
-                ) 
-            if self._state.code is grpc.StatusCode.OK: 
-                return self._state.response 
-            elif self._state.cancelled: 
-                raise grpc.FutureCancelledError() 
-            else: 
-                raise self 
- 
-    def exception(self, timeout=None): 
-        """Return the exception raised by the computation. 
- 
-        This method will never block. Instead, it will raise an exception 
-        if calling this method would otherwise result in blocking. 
- 
-        Since this method will never block, any `timeout` argument passed will 
-        be ignored. 
-        """ 
-        del timeout 
-        with self._state.condition: 
-            if not self._is_complete(): 
-                raise grpc.experimental.UsageError( 
-                    "_SingleThreadedRendezvous only supports exception() when the RPC is complete." 
-                ) 
-            if self._state.code is grpc.StatusCode.OK: 
-                return None 
-            elif self._state.cancelled: 
-                raise grpc.FutureCancelledError() 
-            else: 
-                return self 
- 
-    def traceback(self, timeout=None): 
-        """Access the traceback of the exception raised by the computation. 
- 
-        This method will never block. Instead, it will raise an exception 
-        if calling this method would otherwise result in blocking. 
- 
-        Since this method will never block, any `timeout` argument passed will 
-        be ignored. 
-        """ 
-        del timeout 
-        with self._state.condition: 
-            if not self._is_complete(): 
-                raise grpc.experimental.UsageError( 
-                    "_SingleThreadedRendezvous only supports traceback() when the RPC is complete." 
-                ) 
-            if self._state.code is grpc.StatusCode.OK: 
-                return None 
-            elif self._state.cancelled: 
-                raise grpc.FutureCancelledError() 
-            else: 
-                try: 
-                    raise self 
-                except grpc.RpcError: 
-                    return sys.exc_info()[2] 
- 
-    def add_done_callback(self, fn): 
-        with self._state.condition: 
-            if self._state.code is None: 
-                self._state.callbacks.append(functools.partial(fn, self)) 
-                return 
- 
-        fn(self) 
- 
+    def _is_complete(self):
+        return self._state.code is not None
+
+    def cancelled(self):
+        with self._state.condition:
+            return self._state.cancelled
+
+    def running(self):
+        with self._state.condition:
+            return self._state.code is None
+
+    def done(self):
+        with self._state.condition:
+            return self._state.code is not None
+
+    def result(self, timeout=None):
+        """Returns the result of the computation or raises its exception.
+
+        This method will never block. Instead, it will raise an exception
+        if calling this method would otherwise result in blocking.
+
+        Since this method will never block, any `timeout` argument passed will
+        be ignored.
+        """
+        del timeout
+        with self._state.condition:
+            if not self._is_complete():
+                raise grpc.experimental.UsageError(
+                    "_SingleThreadedRendezvous only supports result() when the RPC is complete."
+                )
+            if self._state.code is grpc.StatusCode.OK:
+                return self._state.response
+            elif self._state.cancelled:
+                raise grpc.FutureCancelledError()
+            else:
+                raise self
+
+    def exception(self, timeout=None):
+        """Return the exception raised by the computation.
+
+        This method will never block. Instead, it will raise an exception
+        if calling this method would otherwise result in blocking.
+
+        Since this method will never block, any `timeout` argument passed will
+        be ignored.
+        """
+        del timeout
+        with self._state.condition:
+            if not self._is_complete():
+                raise grpc.experimental.UsageError(
+                    "_SingleThreadedRendezvous only supports exception() when the RPC is complete."
+                )
+            if self._state.code is grpc.StatusCode.OK:
+                return None
+            elif self._state.cancelled:
+                raise grpc.FutureCancelledError()
+            else:
+                return self
+
+    def traceback(self, timeout=None):
+        """Access the traceback of the exception raised by the computation.
+
+        This method will never block. Instead, it will raise an exception
+        if calling this method would otherwise result in blocking.
+
+        Since this method will never block, any `timeout` argument passed will
+        be ignored.
+        """
+        del timeout
+        with self._state.condition:
+            if not self._is_complete():
+                raise grpc.experimental.UsageError(
+                    "_SingleThreadedRendezvous only supports traceback() when the RPC is complete."
+                )
+            if self._state.code is grpc.StatusCode.OK:
+                return None
+            elif self._state.cancelled:
+                raise grpc.FutureCancelledError()
+            else:
+                try:
+                    raise self
+                except grpc.RpcError:
+                    return sys.exc_info()[2]
+
+    def add_done_callback(self, fn):
+        with self._state.condition:
+            if self._state.code is None:
+                self._state.callbacks.append(functools.partial(fn, self))
+                return
+
+        fn(self)
+
     def initial_metadata(self):
         """See grpc.Call.initial_metadata"""
         with self._state.condition:
@@ -708,9 +708,9 @@ class _MultiThreadedRendezvous(_Rendezvous, grpc.Call, grpc.Future):  # pylint:
         See grpc.Future.result for the full API contract.
         """
         with self._state.condition:
-            timed_out = _common.wait(self._state.condition.wait, 
-                                     self._is_complete, 
-                                     timeout=timeout) 
+            timed_out = _common.wait(self._state.condition.wait,
+                                     self._is_complete,
+                                     timeout=timeout)
             if timed_out:
                 raise grpc.FutureTimeoutError()
             else:
@@ -727,9 +727,9 @@ class _MultiThreadedRendezvous(_Rendezvous, grpc.Call, grpc.Future):  # pylint:
         See grpc.Future.exception for the full API contract.
         """
         with self._state.condition:
-            timed_out = _common.wait(self._state.condition.wait, 
-                                     self._is_complete, 
-                                     timeout=timeout) 
+            timed_out = _common.wait(self._state.condition.wait,
+                                     self._is_complete,
+                                     timeout=timeout)
             if timed_out:
                 raise grpc.FutureTimeoutError()
             else:
@@ -746,9 +746,9 @@ class _MultiThreadedRendezvous(_Rendezvous, grpc.Call, grpc.Future):  # pylint:
         See grpc.future.traceback for the full API contract.
         """
         with self._state.condition:
-            timed_out = _common.wait(self._state.condition.wait, 
-                                     self._is_complete, 
-                                     timeout=timeout) 
+            timed_out = _common.wait(self._state.condition.wait,
+                                     self._is_complete,
+                                     timeout=timeout)
             if timed_out:
                 raise grpc.FutureTimeoutError()
             else:
@@ -843,8 +843,8 @@ def _stream_unary_invocation_operationses_and_tags(metadata,
     return tuple((
         operations,
         None,
-    ) for operations in _stream_unary_invocation_operationses( 
-        metadata, initial_metadata_flags)) 
+    ) for operations in _stream_unary_invocation_operationses(
+        metadata, initial_metadata_flags))
 
 
 def _determine_deadline(user_deadline):
@@ -948,12 +948,12 @@ class _UnaryUnaryMultiCallable(grpc.UnaryUnaryMultiCallable):
             event_handler = _event_handler(state, self._response_deserializer)
             call = self._managed_call(
                 cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS,
-                self._method, None, deadline, metadata, 
-                None if credentials is None else credentials._credentials, 
+                self._method, None, deadline, metadata,
+                None if credentials is None else credentials._credentials,
                 (operations,), event_handler, self._context)
-            return _MultiThreadedRendezvous(state, call, 
-                                            self._response_deserializer, 
-                                            deadline) 
+            return _MultiThreadedRendezvous(state, call,
+                                            self._response_deserializer,
+                                            deadline)
 
 
 class _SingleThreadedUnaryStreamMultiCallable(grpc.UnaryStreamMultiCallable):
@@ -1050,13 +1050,13 @@ class _UnaryStreamMultiCallable(grpc.UnaryStreamMultiCallable):
             call = self._managed_call(
                 cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS,
                 self._method, None, _determine_deadline(deadline), metadata,
-                None if credentials is None else credentials._credentials, 
-                operationses, _event_handler(state, 
-                                             self._response_deserializer), 
-                self._context) 
-            return _MultiThreadedRendezvous(state, call, 
-                                            self._response_deserializer, 
-                                            deadline) 
+                None if credentials is None else credentials._credentials,
+                operationses, _event_handler(state,
+                                             self._response_deserializer),
+                self._context)
+            return _MultiThreadedRendezvous(state, call,
+                                            self._response_deserializer,
+                                            deadline)
 
 
 class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
@@ -1081,8 +1081,8 @@ class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
             metadata, compression)
         call = self._channel.segregated_call(
             cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS, self._method,
-            None, _determine_deadline(deadline), augmented_metadata, 
-            None if credentials is None else credentials._credentials, 
+            None, _determine_deadline(deadline), augmented_metadata,
+            None if credentials is None else credentials._credentials,
             _stream_unary_invocation_operationses_and_tags(
                 augmented_metadata, initial_metadata_flags), self._context)
         _consume_request_iterator(request_iterator, state, call,
@@ -1134,11 +1134,11 @@ class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
             metadata, compression)
         call = self._managed_call(
             cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS, self._method,
-            None, deadline, augmented_metadata, 
-            None if credentials is None else credentials._credentials, 
-            _stream_unary_invocation_operationses(metadata, 
-                                                  initial_metadata_flags), 
-            event_handler, self._context) 
+            None, deadline, augmented_metadata,
+            None if credentials is None else credentials._credentials,
+            _stream_unary_invocation_operationses(metadata,
+                                                  initial_metadata_flags),
+            event_handler, self._context)
         _consume_request_iterator(request_iterator, state, call,
                                   self._request_serializer, event_handler)
         return _MultiThreadedRendezvous(state, call,
@@ -1181,9 +1181,9 @@ class _StreamStreamMultiCallable(grpc.StreamStreamMultiCallable):
         event_handler = _event_handler(state, self._response_deserializer)
         call = self._managed_call(
             cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS, self._method,
-            None, _determine_deadline(deadline), augmented_metadata, 
-            None if credentials is None else credentials._credentials, 
-            operationses, event_handler, self._context) 
+            None, _determine_deadline(deadline), augmented_metadata,
+            None if credentials is None else credentials._credentials,
+            operationses, event_handler, self._context)
         _consume_request_iterator(request_iterator, state, call,
                                   self._request_serializer, event_handler)
         return _MultiThreadedRendezvous(state, call,
@@ -1219,14 +1219,14 @@ class _ChannelCallState(object):
     def reset_postfork_child(self):
         self.managed_calls = 0
 
-    def __del__(self): 
-        try: 
-            self.channel.close(cygrpc.StatusCode.cancelled, 
-                               'Channel deallocated!') 
-        except (TypeError, AttributeError): 
-            pass 
+    def __del__(self):
+        try:
+            self.channel.close(cygrpc.StatusCode.cancelled,
+                               'Channel deallocated!')
+        except (TypeError, AttributeError):
+            pass
+
 
- 
 def _run_channel_spin_thread(state):
 
     def channel_spin():
@@ -1338,13 +1338,13 @@ def _deliver(state, initial_connectivity, initial_callbacks):
 
 
 def _spawn_delivery(state, callbacks):
-    delivering_thread = cygrpc.ForkManagedThread(target=_deliver, 
-                                                 args=( 
-                                                     state, 
-                                                     state.connectivity, 
-                                                     callbacks, 
-                                                 )) 
-    delivering_thread.setDaemon(True) 
+    delivering_thread = cygrpc.ForkManagedThread(target=_deliver,
+                                                 args=(
+                                                     state,
+                                                     state.connectivity,
+                                                     callbacks,
+                                                 ))
+    delivering_thread.setDaemon(True)
     delivering_thread.start()
     state.delivering = True
 
@@ -1355,11 +1355,11 @@ def _poll_connectivity(state, channel, initial_try_to_connect):
     connectivity = channel.check_connectivity_state(try_to_connect)
     with state.lock:
         state.connectivity = (
-            _common. 
-            CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[connectivity]) 
-        callbacks = tuple( 
-            callback for callback, unused_but_known_to_be_none_connectivity in 
-            state.callbacks_and_connectivities) 
+            _common.
+            CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[connectivity])
+        callbacks = tuple(
+            callback for callback, unused_but_known_to_be_none_connectivity in
+            state.callbacks_and_connectivities)
         for callback_and_connectivity in state.callbacks_and_connectivities:
             callback_and_connectivity[1] = state.connectivity
         if callbacks:
@@ -1492,11 +1492,11 @@ class Channel(grpc.Channel):
                 self._channel, _common.encode(method), request_serializer,
                 response_deserializer)
         else:
-            return _UnaryStreamMultiCallable( 
-                self._channel, 
-                _channel_managed_call_management(self._call_state), 
-                _common.encode(method), request_serializer, 
-                response_deserializer) 
+            return _UnaryStreamMultiCallable(
+                self._channel,
+                _channel_managed_call_management(self._call_state),
+                _common.encode(method), request_serializer,
+                response_deserializer)
 
     def stream_unary(self,
                      method,
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_common.py b/contrib/libs/grpc/src/python/grpcio/grpc/_common.py
index 4547a0fe17..128124c325 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_common.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_common.py
@@ -24,15 +24,15 @@ _LOGGER = logging.getLogger(__name__)
 
 CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY = {
     cygrpc.ConnectivityState.idle:
-        grpc.ChannelConnectivity.IDLE, 
+        grpc.ChannelConnectivity.IDLE,
     cygrpc.ConnectivityState.connecting:
-        grpc.ChannelConnectivity.CONNECTING, 
+        grpc.ChannelConnectivity.CONNECTING,
     cygrpc.ConnectivityState.ready:
-        grpc.ChannelConnectivity.READY, 
+        grpc.ChannelConnectivity.READY,
     cygrpc.ConnectivityState.transient_failure:
-        grpc.ChannelConnectivity.TRANSIENT_FAILURE, 
+        grpc.ChannelConnectivity.TRANSIENT_FAILURE,
     cygrpc.ConnectivityState.shutdown:
-        grpc.ChannelConnectivity.SHUTDOWN, 
+        grpc.ChannelConnectivity.SHUTDOWN,
 }
 
 CYGRPC_STATUS_CODE_TO_STATUS_CODE = {
@@ -55,16 +55,16 @@ CYGRPC_STATUS_CODE_TO_STATUS_CODE = {
     cygrpc.StatusCode.data_loss: grpc.StatusCode.DATA_LOSS,
 }
 STATUS_CODE_TO_CYGRPC_STATUS_CODE = {
-    grpc_code: cygrpc_code for cygrpc_code, grpc_code in six.iteritems( 
+    grpc_code: cygrpc_code for cygrpc_code, grpc_code in six.iteritems(
         CYGRPC_STATUS_CODE_TO_STATUS_CODE)
 }
 
 MAXIMUM_WAIT_TIMEOUT = 0.1
 
-_ERROR_MESSAGE_PORT_BINDING_FAILED = 'Failed to bind to address %s; set ' \ 
-    'GRPC_VERBOSITY=debug environment variable to see detailed error message.' 
+_ERROR_MESSAGE_PORT_BINDING_FAILED = 'Failed to bind to address %s; set ' \
+    'GRPC_VERBOSITY=debug environment variable to see detailed error message.'
+
 
- 
 def encode(s):
     if isinstance(s, bytes):
         return s
@@ -147,22 +147,22 @@ def wait(wait_fn, wait_complete_fn, timeout=None, spin_cb=None):
                 return True
             _wait_once(wait_fn, remaining, spin_cb)
     return False
- 
- 
-def validate_port_binding_result(address, port): 
-    """Validates if the port binding succeed. 
- 
-    If the port returned by Core is 0, the binding is failed. However, in that 
-    case, the Core API doesn't return a detailed failing reason. The best we 
-    can do is raising an exception to prevent further confusion. 
- 
-    Args: 
-        address: The address string to be bound. 
-        port: An int returned by core 
-    """ 
-    if port == 0: 
-        # The Core API doesn't return a failure message. The best we can do 
-        # is raising an exception to prevent further confusion. 
-        raise RuntimeError(_ERROR_MESSAGE_PORT_BINDING_FAILED % address) 
-    else: 
-        return port 
+
+
+def validate_port_binding_result(address, port):
+    """Validates if the port binding succeed.
+
+    If the port returned by Core is 0, the binding is failed. However, in that
+    case, the Core API doesn't return a detailed failing reason. The best we
+    can do is raising an exception to prevent further confusion.
+
+    Args:
+        address: The address string to be bound.
+        port: An int returned by core
+    """
+    if port == 0:
+        # The Core API doesn't return a failure message. The best we can do
+        # is raising an exception to prevent further confusion.
+        raise RuntimeError(_ERROR_MESSAGE_PORT_BINDING_FAILED % address)
+    else:
+        return port
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/call.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/call.pxd.pxi
index dc9ecd7a62..867245a694 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/call.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/call.pxd.pxi
@@ -13,35 +13,35 @@
 # limitations under the License.
 
 
-cdef class _AioCall(GrpcCallWrapper): 
+cdef class _AioCall(GrpcCallWrapper):
     cdef:
-        readonly AioChannel _channel 
+        readonly AioChannel _channel
         list _references
-        object _deadline 
-        list _done_callbacks 
- 
-        # Caches the picked event loop, so we can avoid the 30ns overhead each 
-        # time we need access to the event loop. 
-        object _loop 
+        object _deadline
+        list _done_callbacks
 
-        # Flag indicates whether cancel being called or not. Cancellation from 
-        # Core or peer works perfectly fine with normal procedure. However, we 
-        # need this flag to clean up resources for cancellation from the 
-        # application layer. Directly cancelling tasks might cause segfault 
-        # because Core is holding a pointer for the callback handler. 
-        bint _is_locally_cancelled 
- 
-        # Following attributes are used for storing the status of the call and 
-        # the initial metadata. Waiters are used for pausing the execution of 
-        # tasks that are asking for one of the field when they are not yet 
-        # available. 
-        readonly AioRpcStatus _status 
-        readonly tuple _initial_metadata 
-        list _waiters_status 
-        list _waiters_initial_metadata 
- 
-        int _send_initial_metadata_flags 
- 
-    cdef void _create_grpc_call(self, object timeout, bytes method, CallCredentials credentials) except * 
-    cdef void _set_status(self, AioRpcStatus status) except * 
-    cdef void _set_initial_metadata(self, tuple initial_metadata) except * 
+        # Caches the picked event loop, so we can avoid the 30ns overhead each
+        # time we need access to the event loop.
+        object _loop
+
+        # Flag indicates whether cancel being called or not. Cancellation from
+        # Core or peer works perfectly fine with normal procedure. However, we
+        # need this flag to clean up resources for cancellation from the
+        # application layer. Directly cancelling tasks might cause segfault
+        # because Core is holding a pointer for the callback handler.
+        bint _is_locally_cancelled
+
+        # Following attributes are used for storing the status of the call and
+        # the initial metadata. Waiters are used for pausing the execution of
+        # tasks that are asking for one of the field when they are not yet
+        # available.
+        readonly AioRpcStatus _status
+        readonly tuple _initial_metadata
+        list _waiters_status
+        list _waiters_initial_metadata
+
+        int _send_initial_metadata_flags
+
+    cdef void _create_grpc_call(self, object timeout, bytes method, CallCredentials credentials) except *
+    cdef void _set_status(self, AioRpcStatus status) except *
+    cdef void _set_initial_metadata(self, tuple initial_metadata) except *
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/call.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/call.pyx.pxi
index d09569dd1a..10c024e1b3 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/call.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/call.pyx.pxi
@@ -15,493 +15,493 @@
 
 _EMPTY_FLAGS = 0
 _EMPTY_MASK = 0
-_IMMUTABLE_EMPTY_METADATA = tuple() 
-
-_UNKNOWN_CANCELLATION_DETAILS = 'RPC cancelled for unknown reason.' 
-_OK_CALL_REPRESENTATION = ('<{} of RPC that terminated with:\n' 
-                           '\tstatus = {}\n' 
-                           '\tdetails = "{}"\n' 
-                           '>') 
-
-_NON_OK_CALL_REPRESENTATION = ('<{} of RPC that terminated with:\n' 
-                               '\tstatus = {}\n' 
-                               '\tdetails = "{}"\n' 
-                               '\tdebug_error_string = "{}"\n' 
-                               '>') 
-
- 
-cdef int _get_send_initial_metadata_flags(object wait_for_ready) except *: 
-    cdef int flags = 0 
-    # Wait-for-ready can be None, which means using default value in Core. 
-    if wait_for_ready is not None: 
-        flags |= InitialMetadataFlags.wait_for_ready_explicitly_set 
-        if wait_for_ready: 
-            flags |= InitialMetadataFlags.wait_for_ready 
- 
-    flags &= InitialMetadataFlags.used_mask 
-    return flags 
- 
- 
-cdef class _AioCall(GrpcCallWrapper): 
- 
-    def __cinit__(self, AioChannel channel, object deadline, 
-                  bytes method, CallCredentials call_credentials, object wait_for_ready): 
-        init_grpc_aio() 
-        self.call = NULL 
+_IMMUTABLE_EMPTY_METADATA = tuple()
+
+_UNKNOWN_CANCELLATION_DETAILS = 'RPC cancelled for unknown reason.'
+_OK_CALL_REPRESENTATION = ('<{} of RPC that terminated with:\n'
+                           '\tstatus = {}\n'
+                           '\tdetails = "{}"\n'
+                           '>')
+
+_NON_OK_CALL_REPRESENTATION = ('<{} of RPC that terminated with:\n'
+                               '\tstatus = {}\n'
+                               '\tdetails = "{}"\n'
+                               '\tdebug_error_string = "{}"\n'
+                               '>')
+
+
+cdef int _get_send_initial_metadata_flags(object wait_for_ready) except *:
+    cdef int flags = 0
+    # Wait-for-ready can be None, which means using default value in Core.
+    if wait_for_ready is not None:
+        flags |= InitialMetadataFlags.wait_for_ready_explicitly_set
+        if wait_for_ready:
+            flags |= InitialMetadataFlags.wait_for_ready
+
+    flags &= InitialMetadataFlags.used_mask
+    return flags
+
+
+cdef class _AioCall(GrpcCallWrapper):
+
+    def __cinit__(self, AioChannel channel, object deadline,
+                  bytes method, CallCredentials call_credentials, object wait_for_ready):
+        init_grpc_aio()
+        self.call = NULL
         self._channel = channel
-        self._loop = channel.loop 
+        self._loop = channel.loop
         self._references = []
-        self._status = None 
-        self._initial_metadata = None 
-        self._waiters_status = [] 
-        self._waiters_initial_metadata = [] 
-        self._done_callbacks = [] 
-        self._is_locally_cancelled = False 
-        self._deadline = deadline 
-        self._send_initial_metadata_flags = _get_send_initial_metadata_flags(wait_for_ready) 
-        self._create_grpc_call(deadline, method, call_credentials) 
-
-    def __dealloc__(self): 
-        if self.call: 
-            grpc_call_unref(self.call) 
-        shutdown_grpc_aio() 
- 
-    def _repr(self) -> str: 
-        """Assembles the RPC representation string.""" 
-        # This needs to be loaded at run time once everything 
-        # has been loaded. 
-        from grpc import _common 
-
-        if not self.done(): 
-            return '<{} object>'.format(self.__class__.__name__) 
- 
-        if self._status.code() is StatusCode.ok: 
-            return _OK_CALL_REPRESENTATION.format( 
-                self.__class__.__name__, 
-                _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[self._status.code()], 
-                self._status.details()) 
-        else: 
-            return _NON_OK_CALL_REPRESENTATION.format( 
-                self.__class__.__name__, 
-                self._status.details(), 
-                _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[self._status.code()], 
-                self._status.debug_error_string()) 
- 
-    def __repr__(self) -> str: 
-        return self._repr() 
- 
-    def __str__(self) -> str: 
-        return self._repr() 
- 
-    cdef void _create_grpc_call(self, 
-                                object deadline, 
-                                bytes method, 
-                                CallCredentials credentials) except *: 
+        self._status = None
+        self._initial_metadata = None
+        self._waiters_status = []
+        self._waiters_initial_metadata = []
+        self._done_callbacks = []
+        self._is_locally_cancelled = False
+        self._deadline = deadline
+        self._send_initial_metadata_flags = _get_send_initial_metadata_flags(wait_for_ready)
+        self._create_grpc_call(deadline, method, call_credentials)
+
+    def __dealloc__(self):
+        if self.call:
+            grpc_call_unref(self.call)
+        shutdown_grpc_aio()
+
+    def _repr(self) -> str:
+        """Assembles the RPC representation string."""
+        # This needs to be loaded at run time once everything
+        # has been loaded.
+        from grpc import _common
+
+        if not self.done():
+            return '<{} object>'.format(self.__class__.__name__)
+
+        if self._status.code() is StatusCode.ok:
+            return _OK_CALL_REPRESENTATION.format(
+                self.__class__.__name__,
+                _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[self._status.code()],
+                self._status.details())
+        else:
+            return _NON_OK_CALL_REPRESENTATION.format(
+                self.__class__.__name__,
+                self._status.details(),
+                _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[self._status.code()],
+                self._status.debug_error_string())
+
+    def __repr__(self) -> str:
+        return self._repr()
+
+    def __str__(self) -> str:
+        return self._repr()
+
+    cdef void _create_grpc_call(self,
+                                object deadline,
+                                bytes method,
+                                CallCredentials credentials) except *:
         """Creates the corresponding Core object for this RPC.
 
-        For unary calls, the grpc_call lives shortly and can be destroyed after 
+        For unary calls, the grpc_call lives shortly and can be destroyed after
         invoke start_batch. However, if either side is streaming, the grpc_call
         life span will be longer than one function. So, it would better save it
         as an instance variable than a stack variable, which reflects its
         nature in Core.
         """
         cdef grpc_slice method_slice
-        cdef gpr_timespec c_deadline = _timespec_from_time(deadline) 
-        cdef grpc_call_error set_credentials_error 
+        cdef gpr_timespec c_deadline = _timespec_from_time(deadline)
+        cdef grpc_call_error set_credentials_error
 
         method_slice = grpc_slice_from_copied_buffer(
             <const char *> method,
             <size_t> len(method)
         )
-        self.call = grpc_channel_create_call( 
+        self.call = grpc_channel_create_call(
             self._channel.channel,
             NULL,
             _EMPTY_MASK,
-            global_completion_queue(), 
+            global_completion_queue(),
             method_slice,
             NULL,
-            c_deadline, 
+            c_deadline,
             NULL
         )
- 
-        if credentials is not None: 
-            set_credentials_error = grpc_call_set_credentials(self.call, credentials.c()) 
-            if set_credentials_error != GRPC_CALL_OK: 
-                raise InternalError("Credentials couldn't have been set: {0}".format(set_credentials_error)) 
- 
+
+        if credentials is not None:
+            set_credentials_error = grpc_call_set_credentials(self.call, credentials.c())
+            if set_credentials_error != GRPC_CALL_OK:
+                raise InternalError("Credentials couldn't have been set: {0}".format(set_credentials_error))
+
         grpc_slice_unref(method_slice)
 
-    cdef void _set_status(self, AioRpcStatus status) except *: 
-        cdef list waiters 
- 
-        self._status = status 
- 
-        if self._initial_metadata is None: 
-            self._set_initial_metadata(_IMMUTABLE_EMPTY_METADATA) 
- 
-        # No more waiters should be expected since status 
-        # has been set. 
-        waiters = self._waiters_status 
-        self._waiters_status = None 
- 
-        for waiter in waiters: 
-            if not waiter.done(): 
-                waiter.set_result(None) 
- 
-        for callback in self._done_callbacks: 
-            callback() 
- 
-    cdef void _set_initial_metadata(self, tuple initial_metadata) except *: 
-        cdef list waiters 
- 
-        self._initial_metadata = initial_metadata 
- 
-        # No more waiters should be expected since initial metadata 
-        # has been set. 
-        waiters = self._waiters_initial_metadata 
-        self._waiters_initial_metadata = None 
- 
-        for waiter in waiters: 
-            if not waiter.done(): 
-                waiter.set_result(None) 
- 
- 
-    def add_done_callback(self, callback): 
-        if self.done(): 
-            callback() 
-        else: 
-            self._done_callbacks.append(callback) 
- 
-    def time_remaining(self): 
-        if self._deadline is None: 
-            return None 
-        else: 
-            return max(0, self._deadline - time.time()) 
-
-    def cancel(self, str details): 
-        """Cancels the RPC in Core with given RPC status. 
- 
-        Above abstractions must invoke this method to set Core objects into 
-        proper state. 
-        """ 
-        self._is_locally_cancelled = True 
-
-        cdef object details_bytes 
-        cdef char *c_details 
-        cdef grpc_call_error error 
-
-        self._set_status(AioRpcStatus( 
-            StatusCode.cancelled, 
-            details, 
-            None, 
-            None, 
-        )) 
- 
-        details_bytes = str_to_bytes(details) 
-        self._references.append(details_bytes) 
-        c_details = <char *>details_bytes 
-        # By implementation, grpc_call_cancel_with_status always return OK 
-        error = grpc_call_cancel_with_status( 
-            self.call, 
-            StatusCode.cancelled, 
-            c_details, 
-            NULL, 
-        ) 
-        assert error == GRPC_CALL_OK 
- 
-    def done(self): 
-        """Returns if the RPC call has finished. 
- 
-        Checks if the status has been provided, either 
-        because the RPC finished or because was cancelled.. 
- 
-        Returns: 
-            True if the RPC can be considered finished. 
-        """ 
-        return self._status is not None 
- 
-    def cancelled(self): 
-        """Returns if the RPC was cancelled. 
- 
-        Returns: 
-            True if the RPC was cancelled. 
-        """ 
-        if not self.done(): 
-            return False 
- 
-        return self._status.code() == StatusCode.cancelled 
- 
-    async def status(self): 
-        """Returns the status of the RPC call. 
- 
-        It returns the finshed status of the RPC. If the RPC 
-        has not finished yet this function will wait until the RPC 
-        gets finished. 
- 
-        Returns: 
-            Finished status of the RPC as an AioRpcStatus object. 
-        """ 
-        if self._status is not None: 
-            return self._status 
- 
-        future = self._loop.create_future() 
-        self._waiters_status.append(future) 
-        await future 
- 
-        return self._status 
- 
-    def is_ok(self): 
-        """Returns if the RPC is ended with ok.""" 
-        return self.done() and self._status.code() == StatusCode.ok 
- 
-    async def initial_metadata(self): 
-        """Returns the initial metadata of the RPC call. 
- 
-        If the initial metadata has not been received yet this function will 
-        wait until the RPC gets finished. 
- 
-        Returns: 
-            The tuple object with the initial metadata. 
-        """ 
-        if self._initial_metadata is not None: 
-            return self._initial_metadata 
- 
-        future = self._loop.create_future() 
-        self._waiters_initial_metadata.append(future) 
-        await future 
- 
-        return self._initial_metadata 
- 
-    def is_locally_cancelled(self): 
-        """Returns if the RPC was cancelled locally. 
- 
-        Returns: 
-            True when was cancelled locally, False when was cancelled remotelly or 
-            is still ongoing. 
-        """ 
-        if self._is_locally_cancelled: 
-            return True 
- 
-        return False 
- 
-    async def unary_unary(self, 
-                          bytes request, 
-                          tuple outbound_initial_metadata): 
-        """Performs a unary unary RPC. 
- 
-        Args: 
-          request: the serialized requests in bytes. 
-          outbound_initial_metadata: optional outbound metadata. 
-        """ 
-        cdef tuple ops 
-
-        cdef SendInitialMetadataOperation initial_metadata_op = SendInitialMetadataOperation( 
-            outbound_initial_metadata, 
-            self._send_initial_metadata_flags) 
-        cdef SendMessageOperation send_message_op = SendMessageOperation(request, _EMPTY_FLAGS) 
-        cdef SendCloseFromClientOperation send_close_op = SendCloseFromClientOperation(_EMPTY_FLAGS) 
-        cdef ReceiveInitialMetadataOperation receive_initial_metadata_op = ReceiveInitialMetadataOperation(_EMPTY_FLAGS) 
-        cdef ReceiveMessageOperation receive_message_op = ReceiveMessageOperation(_EMPTY_FLAGS) 
-        cdef ReceiveStatusOnClientOperation receive_status_on_client_op = ReceiveStatusOnClientOperation(_EMPTY_FLAGS) 
-
-        ops = (initial_metadata_op, send_message_op, send_close_op, 
-               receive_initial_metadata_op, receive_message_op, 
-               receive_status_on_client_op) 
-
-        # Executes all operations in one batch. 
-        # Might raise CancelledError, handling it in Python UnaryUnaryCall. 
-        await execute_batch(self, 
-                            ops, 
-                            self._loop) 
-
-        self._set_initial_metadata(receive_initial_metadata_op.initial_metadata()) 
-
-        cdef grpc_status_code code 
-        code = receive_status_on_client_op.code() 
- 
-        self._set_status(AioRpcStatus( 
-            code, 
-            receive_status_on_client_op.details(), 
-            receive_status_on_client_op.trailing_metadata(), 
-            receive_status_on_client_op.error_string(), 
-        )) 
-
-        if code == StatusCode.ok: 
-            return receive_message_op.message() 
-        else: 
-            return None 
-
-    async def _handle_status_once_received(self): 
-        """Handles the status sent by peer once received.""" 
-        cdef ReceiveStatusOnClientOperation op = ReceiveStatusOnClientOperation(_EMPTY_FLAGS) 
-        cdef tuple ops = (op,) 
-        await execute_batch(self, ops, self._loop) 
- 
-        # Halts if the RPC is locally cancelled 
-        if self._is_locally_cancelled: 
-            return 
- 
-        self._set_status(AioRpcStatus( 
-            op.code(), 
-            op.details(), 
-            op.trailing_metadata(), 
-            op.error_string(), 
-        )) 
-
-    async def receive_serialized_message(self): 
-        """Receives one single raw message in bytes.""" 
-        cdef bytes received_message 
-
-        # Receives a message. Returns None when failed: 
-        # * EOF, no more messages to read; 
-        # * The client application cancels; 
-        # * The server sends final status. 
-        received_message = await _receive_message( 
-            self, 
-            self._loop 
-        ) 
-        if received_message: 
-            return received_message 
-        else: 
-            return EOF 
-
-    async def send_serialized_message(self, bytes message): 
-        """Sends one single raw message in bytes.""" 
-        await _send_message(self, 
-                            message, 
-                            None, 
-                            False, 
-                            self._loop) 
-
-    async def send_receive_close(self): 
-        """Half close the RPC on the client-side.""" 
-        cdef SendCloseFromClientOperation op = SendCloseFromClientOperation(_EMPTY_FLAGS) 
-        cdef tuple ops = (op,) 
-        await execute_batch(self, ops, self._loop) 
- 
-    async def initiate_unary_stream(self, 
-                           bytes request, 
-                           tuple outbound_initial_metadata): 
-        """Implementation of the start of a unary-stream call.""" 
-        # Peer may prematurely end this RPC at any point. We need a corutine 
-        # that watches if the server sends the final status. 
-        status_task = self._loop.create_task(self._handle_status_once_received()) 
- 
-        cdef tuple outbound_ops 
-        cdef Operation initial_metadata_op = SendInitialMetadataOperation( 
-            outbound_initial_metadata, 
-            self._send_initial_metadata_flags) 
-        cdef Operation send_message_op = SendMessageOperation( 
-            request, 
-            _EMPTY_FLAGS) 
-        cdef Operation send_close_op = SendCloseFromClientOperation( 
-            _EMPTY_FLAGS) 
- 
-        outbound_ops = ( 
-            initial_metadata_op, 
-            send_message_op, 
-            send_close_op, 
+    cdef void _set_status(self, AioRpcStatus status) except *:
+        cdef list waiters
+
+        self._status = status
+
+        if self._initial_metadata is None:
+            self._set_initial_metadata(_IMMUTABLE_EMPTY_METADATA)
+
+        # No more waiters should be expected since status
+        # has been set.
+        waiters = self._waiters_status
+        self._waiters_status = None
+
+        for waiter in waiters:
+            if not waiter.done():
+                waiter.set_result(None)
+
+        for callback in self._done_callbacks:
+            callback()
+
+    cdef void _set_initial_metadata(self, tuple initial_metadata) except *:
+        cdef list waiters
+
+        self._initial_metadata = initial_metadata
+
+        # No more waiters should be expected since initial metadata
+        # has been set.
+        waiters = self._waiters_initial_metadata
+        self._waiters_initial_metadata = None
+
+        for waiter in waiters:
+            if not waiter.done():
+                waiter.set_result(None)
+
+
+    def add_done_callback(self, callback):
+        if self.done():
+            callback()
+        else:
+            self._done_callbacks.append(callback)
+
+    def time_remaining(self):
+        if self._deadline is None:
+            return None
+        else:
+            return max(0, self._deadline - time.time())
+
+    def cancel(self, str details):
+        """Cancels the RPC in Core with given RPC status.
+
+        Above abstractions must invoke this method to set Core objects into
+        proper state.
+        """
+        self._is_locally_cancelled = True
+
+        cdef object details_bytes
+        cdef char *c_details
+        cdef grpc_call_error error
+
+        self._set_status(AioRpcStatus(
+            StatusCode.cancelled,
+            details,
+            None,
+            None,
+        ))
+
+        details_bytes = str_to_bytes(details)
+        self._references.append(details_bytes)
+        c_details = <char *>details_bytes
+        # By implementation, grpc_call_cancel_with_status always return OK
+        error = grpc_call_cancel_with_status(
+            self.call,
+            StatusCode.cancelled,
+            c_details,
+            NULL,
         )
- 
-        try: 
-            # Sends out the request message. 
-            await execute_batch(self, 
-                                outbound_ops, 
-                                self._loop) 
- 
-            # Receives initial metadata. 
-            self._set_initial_metadata( 
-                await _receive_initial_metadata(self, 
-                                                self._loop), 
-            ) 
-        except ExecuteBatchError as batch_error: 
-            # Core should explain why this batch failed 
-            await status_task 
- 
-    async def stream_unary(self, 
-                           tuple outbound_initial_metadata, 
-                           object metadata_sent_observer): 
-        """Actual implementation of the complete unary-stream call. 
- 
-        Needs to pay extra attention to the raise mechanism. If we want to 
-        propagate the final status exception, then we have to raise it. 
-        Othersize, it would end normally and raise `StopAsyncIteration()`. 
-        """ 
-        try: 
-            # Sends out initial_metadata ASAP. 
-            await _send_initial_metadata(self, 
-                                        outbound_initial_metadata, 
-                                        self._send_initial_metadata_flags, 
-                                        self._loop) 
-            # Notify upper level that sending messages are allowed now. 
-            metadata_sent_observer() 
- 
-            # Receives initial metadata. 
-            self._set_initial_metadata( 
-                await _receive_initial_metadata(self, self._loop) 
-            ) 
-        except ExecuteBatchError: 
-            # Core should explain why this batch failed 
-            await self._handle_status_once_received() 
- 
-            # Allow upper layer to proceed only if the status is set 
-            metadata_sent_observer() 
-            return None 
- 
-        cdef tuple inbound_ops 
-        cdef ReceiveMessageOperation receive_message_op = ReceiveMessageOperation(_EMPTY_FLAGS) 
-        cdef ReceiveStatusOnClientOperation receive_status_on_client_op = ReceiveStatusOnClientOperation(_EMPTY_FLAGS) 
-        inbound_ops = (receive_message_op, receive_status_on_client_op) 
- 
-        # Executes all operations in one batch. 
-        await execute_batch(self, 
-                            inbound_ops, 
-                            self._loop) 
- 
-        cdef grpc_status_code code 
-        code = receive_status_on_client_op.code() 
- 
-        self._set_status(AioRpcStatus( 
-            code, 
-            receive_status_on_client_op.details(), 
-            receive_status_on_client_op.trailing_metadata(), 
-            receive_status_on_client_op.error_string(), 
-        )) 
- 
-        if code == StatusCode.ok: 
-            return receive_message_op.message() 
-        else: 
-            return None 
- 
-    async def initiate_stream_stream(self, 
-                           tuple outbound_initial_metadata, 
-                           object metadata_sent_observer): 
-        """Actual implementation of the complete stream-stream call. 
- 
-        Needs to pay extra attention to the raise mechanism. If we want to 
-        propagate the final status exception, then we have to raise it. 
-        Othersize, it would end normally and raise `StopAsyncIteration()`. 
-        """ 
-        # Peer may prematurely end this RPC at any point. We need a corutine 
-        # that watches if the server sends the final status. 
-        status_task = self._loop.create_task(self._handle_status_once_received()) 
- 
-        try: 
-            # Sends out initial_metadata ASAP. 
-            await _send_initial_metadata(self, 
-                                        outbound_initial_metadata, 
-                                        self._send_initial_metadata_flags, 
-                                        self._loop) 
-            # Notify upper level that sending messages are allowed now. 
-            metadata_sent_observer() 
- 
-            # Receives initial metadata. 
-            self._set_initial_metadata( 
-                await _receive_initial_metadata(self, self._loop) 
-            ) 
-        except ExecuteBatchError as batch_error: 
-            # Core should explain why this batch failed 
-            await status_task 
- 
-            # Allow upper layer to proceed only if the status is set 
-            metadata_sent_observer() 
+        assert error == GRPC_CALL_OK
+
+    def done(self):
+        """Returns if the RPC call has finished.
+
+        Checks if the status has been provided, either
+        because the RPC finished or because was cancelled..
+
+        Returns:
+            True if the RPC can be considered finished.
+        """
+        return self._status is not None
+
+    def cancelled(self):
+        """Returns if the RPC was cancelled.
+
+        Returns:
+            True if the RPC was cancelled.
+        """
+        if not self.done():
+            return False
+
+        return self._status.code() == StatusCode.cancelled
+
+    async def status(self):
+        """Returns the status of the RPC call.
+
+        It returns the finshed status of the RPC. If the RPC
+        has not finished yet this function will wait until the RPC
+        gets finished.
+
+        Returns:
+            Finished status of the RPC as an AioRpcStatus object.
+        """
+        if self._status is not None:
+            return self._status
+
+        future = self._loop.create_future()
+        self._waiters_status.append(future)
+        await future
+
+        return self._status
+
+    def is_ok(self):
+        """Returns if the RPC is ended with ok."""
+        return self.done() and self._status.code() == StatusCode.ok
+
+    async def initial_metadata(self):
+        """Returns the initial metadata of the RPC call.
+
+        If the initial metadata has not been received yet this function will
+        wait until the RPC gets finished.
+
+        Returns:
+            The tuple object with the initial metadata.
+        """
+        if self._initial_metadata is not None:
+            return self._initial_metadata
+
+        future = self._loop.create_future()
+        self._waiters_initial_metadata.append(future)
+        await future
+
+        return self._initial_metadata
+
+    def is_locally_cancelled(self):
+        """Returns if the RPC was cancelled locally.
+
+        Returns:
+            True when was cancelled locally, False when was cancelled remotelly or
+            is still ongoing.
+        """
+        if self._is_locally_cancelled:
+            return True
+
+        return False
+
+    async def unary_unary(self,
+                          bytes request,
+                          tuple outbound_initial_metadata):
+        """Performs a unary unary RPC.
+
+        Args:
+          request: the serialized requests in bytes.
+          outbound_initial_metadata: optional outbound metadata.
+        """
+        cdef tuple ops
+
+        cdef SendInitialMetadataOperation initial_metadata_op = SendInitialMetadataOperation(
+            outbound_initial_metadata,
+            self._send_initial_metadata_flags)
+        cdef SendMessageOperation send_message_op = SendMessageOperation(request, _EMPTY_FLAGS)
+        cdef SendCloseFromClientOperation send_close_op = SendCloseFromClientOperation(_EMPTY_FLAGS)
+        cdef ReceiveInitialMetadataOperation receive_initial_metadata_op = ReceiveInitialMetadataOperation(_EMPTY_FLAGS)
+        cdef ReceiveMessageOperation receive_message_op = ReceiveMessageOperation(_EMPTY_FLAGS)
+        cdef ReceiveStatusOnClientOperation receive_status_on_client_op = ReceiveStatusOnClientOperation(_EMPTY_FLAGS)
+
+        ops = (initial_metadata_op, send_message_op, send_close_op,
+               receive_initial_metadata_op, receive_message_op,
+               receive_status_on_client_op)
+
+        # Executes all operations in one batch.
+        # Might raise CancelledError, handling it in Python UnaryUnaryCall.
+        await execute_batch(self,
+                            ops,
+                            self._loop)
+
+        self._set_initial_metadata(receive_initial_metadata_op.initial_metadata())
+
+        cdef grpc_status_code code
+        code = receive_status_on_client_op.code()
+
+        self._set_status(AioRpcStatus(
+            code,
+            receive_status_on_client_op.details(),
+            receive_status_on_client_op.trailing_metadata(),
+            receive_status_on_client_op.error_string(),
+        ))
+
+        if code == StatusCode.ok:
+            return receive_message_op.message()
+        else:
+            return None
+
+    async def _handle_status_once_received(self):
+        """Handles the status sent by peer once received."""
+        cdef ReceiveStatusOnClientOperation op = ReceiveStatusOnClientOperation(_EMPTY_FLAGS)
+        cdef tuple ops = (op,)
+        await execute_batch(self, ops, self._loop)
+
+        # Halts if the RPC is locally cancelled
+        if self._is_locally_cancelled:
+            return
+
+        self._set_status(AioRpcStatus(
+            op.code(),
+            op.details(),
+            op.trailing_metadata(),
+            op.error_string(),
+        ))
+
+    async def receive_serialized_message(self):
+        """Receives one single raw message in bytes."""
+        cdef bytes received_message
+
+        # Receives a message. Returns None when failed:
+        # * EOF, no more messages to read;
+        # * The client application cancels;
+        # * The server sends final status.
+        received_message = await _receive_message(
+            self,
+            self._loop
+        )
+        if received_message:
+            return received_message
+        else:
+            return EOF
+
+    async def send_serialized_message(self, bytes message):
+        """Sends one single raw message in bytes."""
+        await _send_message(self,
+                            message,
+                            None,
+                            False,
+                            self._loop)
+
+    async def send_receive_close(self):
+        """Half close the RPC on the client-side."""
+        cdef SendCloseFromClientOperation op = SendCloseFromClientOperation(_EMPTY_FLAGS)
+        cdef tuple ops = (op,)
+        await execute_batch(self, ops, self._loop)
+
+    async def initiate_unary_stream(self,
+                           bytes request,
+                           tuple outbound_initial_metadata):
+        """Implementation of the start of a unary-stream call."""
+        # Peer may prematurely end this RPC at any point. We need a corutine
+        # that watches if the server sends the final status.
+        status_task = self._loop.create_task(self._handle_status_once_received())
+
+        cdef tuple outbound_ops
+        cdef Operation initial_metadata_op = SendInitialMetadataOperation(
+            outbound_initial_metadata,
+            self._send_initial_metadata_flags)
+        cdef Operation send_message_op = SendMessageOperation(
+            request,
+            _EMPTY_FLAGS)
+        cdef Operation send_close_op = SendCloseFromClientOperation(
+            _EMPTY_FLAGS)
+
+        outbound_ops = (
+            initial_metadata_op,
+            send_message_op,
+            send_close_op,
+        )
+
+        try:
+            # Sends out the request message.
+            await execute_batch(self,
+                                outbound_ops,
+                                self._loop)
+
+            # Receives initial metadata.
+            self._set_initial_metadata(
+                await _receive_initial_metadata(self,
+                                                self._loop),
+            )
+        except ExecuteBatchError as batch_error:
+            # Core should explain why this batch failed
+            await status_task
+
+    async def stream_unary(self,
+                           tuple outbound_initial_metadata,
+                           object metadata_sent_observer):
+        """Actual implementation of the complete unary-stream call.
+
+        Needs to pay extra attention to the raise mechanism. If we want to
+        propagate the final status exception, then we have to raise it.
+        Othersize, it would end normally and raise `StopAsyncIteration()`.
+        """
+        try:
+            # Sends out initial_metadata ASAP.
+            await _send_initial_metadata(self,
+                                        outbound_initial_metadata,
+                                        self._send_initial_metadata_flags,
+                                        self._loop)
+            # Notify upper level that sending messages are allowed now.
+            metadata_sent_observer()
+
+            # Receives initial metadata.
+            self._set_initial_metadata(
+                await _receive_initial_metadata(self, self._loop)
+            )
+        except ExecuteBatchError:
+            # Core should explain why this batch failed
+            await self._handle_status_once_received()
+
+            # Allow upper layer to proceed only if the status is set
+            metadata_sent_observer()
+            return None
+
+        cdef tuple inbound_ops
+        cdef ReceiveMessageOperation receive_message_op = ReceiveMessageOperation(_EMPTY_FLAGS)
+        cdef ReceiveStatusOnClientOperation receive_status_on_client_op = ReceiveStatusOnClientOperation(_EMPTY_FLAGS)
+        inbound_ops = (receive_message_op, receive_status_on_client_op)
+
+        # Executes all operations in one batch.
+        await execute_batch(self,
+                            inbound_ops,
+                            self._loop)
+
+        cdef grpc_status_code code
+        code = receive_status_on_client_op.code()
+
+        self._set_status(AioRpcStatus(
+            code,
+            receive_status_on_client_op.details(),
+            receive_status_on_client_op.trailing_metadata(),
+            receive_status_on_client_op.error_string(),
+        ))
+
+        if code == StatusCode.ok:
+            return receive_message_op.message()
+        else:
+            return None
+
+    async def initiate_stream_stream(self,
+                           tuple outbound_initial_metadata,
+                           object metadata_sent_observer):
+        """Actual implementation of the complete stream-stream call.
+
+        Needs to pay extra attention to the raise mechanism. If we want to
+        propagate the final status exception, then we have to raise it.
+        Othersize, it would end normally and raise `StopAsyncIteration()`.
+        """
+        # Peer may prematurely end this RPC at any point. We need a corutine
+        # that watches if the server sends the final status.
+        status_task = self._loop.create_task(self._handle_status_once_received())
+
+        try:
+            # Sends out initial_metadata ASAP.
+            await _send_initial_metadata(self,
+                                        outbound_initial_metadata,
+                                        self._send_initial_metadata_flags,
+                                        self._loop)
+            # Notify upper level that sending messages are allowed now.
+            metadata_sent_observer()
+
+            # Receives initial metadata.
+            self._set_initial_metadata(
+                await _receive_initial_metadata(self, self._loop)
+            )
+        except ExecuteBatchError as batch_error:
+            # Core should explain why this batch failed
+            await status_task
+
+            # Allow upper layer to proceed only if the status is set
+            metadata_sent_observer()
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/callback_common.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/callback_common.pxd.pxi
index 73c04507fc..e5620cd166 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/callback_common.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/callback_common.pxd.pxi
@@ -26,18 +26,18 @@ cdef struct CallbackContext:
     #    
     #   Attributes:
     #     functor: A grpc_experimental_completion_queue_functor represents the
-    #       callback function in the only way Core understands. 
+    #       callback function in the only way Core understands.
     #     waiter: An asyncio.Future object that fulfills when the callback is
-    #       invoked by Core. 
-    #     failure_handler: A CallbackFailureHandler object that called when Core 
+    #       invoked by Core.
+    #     failure_handler: A CallbackFailureHandler object that called when Core
     #       returns 'success == 0' state.
-    #     wrapper: A self-reference to the CallbackWrapper to help life cycle 
-    #       management. 
+    #     wrapper: A self-reference to the CallbackWrapper to help life cycle
+    #       management.
     grpc_experimental_completion_queue_functor functor
     cpython.PyObject *waiter
-    cpython.PyObject *loop 
+    cpython.PyObject *loop
     cpython.PyObject *failure_handler
-    cpython.PyObject *callback_wrapper 
+    cpython.PyObject *callback_wrapper
 
 
 cdef class CallbackWrapper:
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/callback_common.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/callback_common.pyx.pxi
index 05c51aec74..86fc91e76a 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/callback_common.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/callback_common.pyx.pxi
@@ -14,7 +14,7 @@
 
 
 cdef class CallbackFailureHandler:
- 
+
     def __cinit__(self,
                   str core_function_name,
                   object error_details,
@@ -32,33 +32,33 @@ cdef class CallbackFailureHandler:
 
 cdef class CallbackWrapper:
 
-    def __cinit__(self, object future, object loop, CallbackFailureHandler failure_handler): 
+    def __cinit__(self, object future, object loop, CallbackFailureHandler failure_handler):
         self.context.functor.functor_run = self.functor_run
         self.context.waiter = <cpython.PyObject*>future
-        self.context.loop = <cpython.PyObject*>loop 
+        self.context.loop = <cpython.PyObject*>loop
         self.context.failure_handler = <cpython.PyObject*>failure_handler
-        self.context.callback_wrapper = <cpython.PyObject*>self 
+        self.context.callback_wrapper = <cpython.PyObject*>self
         # NOTE(lidiz) Not using a list here, because this class is critical in
         # data path. We should make it as efficient as possible.
         self._reference_of_future = future
         self._reference_of_failure_handler = failure_handler
-        # NOTE(lidiz) We need to ensure when Core invokes our callback, the 
-        # callback function itself is not deallocated. Othersise, we will get 
-        # a segfault. We can view this as Core holding a ref. 
-        cpython.Py_INCREF(self) 
+        # NOTE(lidiz) We need to ensure when Core invokes our callback, the
+        # callback function itself is not deallocated. Othersise, we will get
+        # a segfault. We can view this as Core holding a ref.
+        cpython.Py_INCREF(self)
 
     @staticmethod
     cdef void functor_run(
             grpc_experimental_completion_queue_functor* functor,
             int success):
         cdef CallbackContext *context = <CallbackContext *>functor
-        cdef object waiter = <object>context.waiter 
-        if not waiter.cancelled(): 
-            if success == 0: 
-                (<CallbackFailureHandler>context.failure_handler).handle(waiter) 
-            else: 
-                waiter.set_result(None) 
-        cpython.Py_DECREF(<object>context.callback_wrapper) 
+        cdef object waiter = <object>context.waiter
+        if not waiter.cancelled():
+            if success == 0:
+                (<CallbackFailureHandler>context.failure_handler).handle(waiter)
+            else:
+                waiter.set_result(None)
+        cpython.Py_DECREF(<object>context.callback_wrapper)
 
     cdef grpc_experimental_completion_queue_functor *c_functor(self):
         return &self.context.functor
@@ -67,14 +67,14 @@ cdef class CallbackWrapper:
 cdef CallbackFailureHandler CQ_SHUTDOWN_FAILURE_HANDLER = CallbackFailureHandler(
     'grpc_completion_queue_shutdown',
     'Unknown',
-    InternalError) 
+    InternalError)
 
 
-class ExecuteBatchError(InternalError): 
-    """Raised when execute batch returns a failure from Core.""" 
+class ExecuteBatchError(InternalError):
+    """Raised when execute batch returns a failure from Core."""
 
 
-async def execute_batch(GrpcCallWrapper grpc_call_wrapper, 
+async def execute_batch(GrpcCallWrapper grpc_call_wrapper,
                                tuple operations,
                                object loop):
     """The callback version of start batch operations."""
@@ -84,8 +84,8 @@ async def execute_batch(GrpcCallWrapper grpc_call_wrapper,
     cdef object future = loop.create_future()
     cdef CallbackWrapper wrapper = CallbackWrapper(
         future,
-        loop, 
-        CallbackFailureHandler('execute_batch', operations, ExecuteBatchError)) 
+        loop,
+        CallbackFailureHandler('execute_batch', operations, ExecuteBatchError))
     cdef grpc_call_error error = grpc_call_start_batch(
         grpc_call_wrapper.call,
         batch_operation_tag.c_ops,
@@ -93,90 +93,90 @@ async def execute_batch(GrpcCallWrapper grpc_call_wrapper,
         wrapper.c_functor(), NULL)
 
     if error != GRPC_CALL_OK:
-        raise ExecuteBatchError("Failed grpc_call_start_batch: {}".format(error)) 
+        raise ExecuteBatchError("Failed grpc_call_start_batch: {}".format(error))
 
     await future
- 
+
     cdef grpc_event c_event
     # Tag.event must be called, otherwise messages won't be parsed from C
     batch_operation_tag.event(c_event)
- 
- 
-cdef prepend_send_initial_metadata_op(tuple ops, tuple metadata): 
-    # Eventually, this function should be the only function that produces 
-    # SendInitialMetadataOperation. So we have more control over the flag. 
-    return (SendInitialMetadataOperation( 
-        metadata, 
-        _EMPTY_FLAG 
-    ),) + ops 
- 
- 
-async def _receive_message(GrpcCallWrapper grpc_call_wrapper, 
-                           object loop): 
-    """Retrives parsed messages from Core. 
- 
-    The messages maybe already in Core's buffer, so there isn't a 1-to-1 
-    mapping between this and the underlying "socket.read()". Also, eventually, 
-    this function will end with an EOF, which reads empty message. 
-    """ 
-    cdef ReceiveMessageOperation receive_op = ReceiveMessageOperation(_EMPTY_FLAG) 
-    cdef tuple ops = (receive_op,) 
-    try: 
-        await execute_batch(grpc_call_wrapper, ops, loop) 
-    except ExecuteBatchError as e: 
-        # NOTE(lidiz) The receive message operation has two ways to indicate 
-        # finish state : 1) returns empty message due to EOF; 2) fails inside 
-        # the callback (e.g. cancelled). 
-        # 
-        # Since they all indicates finish, they are better be merged. 
-        _LOGGER.debug('Failed to receive any message from Core') 
-    return receive_op.message() 
- 
- 
-async def _send_message(GrpcCallWrapper grpc_call_wrapper, 
-                        bytes message, 
-                        Operation send_initial_metadata_op, 
-                        int write_flag, 
-                        object loop): 
-    cdef SendMessageOperation op = SendMessageOperation(message, write_flag) 
-    cdef tuple ops = (op,) 
-    if send_initial_metadata_op is not None: 
-        ops = (send_initial_metadata_op,) + ops 
-    await execute_batch(grpc_call_wrapper, ops, loop) 
- 
- 
-async def _send_initial_metadata(GrpcCallWrapper grpc_call_wrapper, 
-                                 tuple metadata, 
-                                 int flags, 
-                                 object loop): 
-    cdef SendInitialMetadataOperation op = SendInitialMetadataOperation( 
-        metadata, 
-        flags) 
-    cdef tuple ops = (op,) 
-    await execute_batch(grpc_call_wrapper, ops, loop) 
- 
- 
-async def _receive_initial_metadata(GrpcCallWrapper grpc_call_wrapper, 
-                                    object loop): 
-    cdef ReceiveInitialMetadataOperation op = ReceiveInitialMetadataOperation(_EMPTY_FLAGS) 
-    cdef tuple ops = (op,) 
-    await execute_batch(grpc_call_wrapper, ops, loop) 
-    return op.initial_metadata() 
- 
-async def _send_error_status_from_server(GrpcCallWrapper grpc_call_wrapper, 
-                                         grpc_status_code code, 
-                                         str details, 
-                                         tuple trailing_metadata, 
-                                         Operation send_initial_metadata_op, 
-                                         object loop): 
-    assert code != StatusCode.ok, 'Expecting non-ok status code.' 
-    cdef SendStatusFromServerOperation op = SendStatusFromServerOperation( 
-        trailing_metadata, 
-        code, 
-        details, 
-        _EMPTY_FLAGS, 
-    ) 
-    cdef tuple ops = (op,) 
-    if send_initial_metadata_op is not None: 
-        ops = (send_initial_metadata_op,) + ops 
-    await execute_batch(grpc_call_wrapper, ops, loop) 
+
+
+cdef prepend_send_initial_metadata_op(tuple ops, tuple metadata):
+    # Eventually, this function should be the only function that produces
+    # SendInitialMetadataOperation. So we have more control over the flag.
+    return (SendInitialMetadataOperation(
+        metadata,
+        _EMPTY_FLAG
+    ),) + ops
+
+
+async def _receive_message(GrpcCallWrapper grpc_call_wrapper,
+                           object loop):
+    """Retrives parsed messages from Core.
+
+    The messages maybe already in Core's buffer, so there isn't a 1-to-1
+    mapping between this and the underlying "socket.read()". Also, eventually,
+    this function will end with an EOF, which reads empty message.
+    """
+    cdef ReceiveMessageOperation receive_op = ReceiveMessageOperation(_EMPTY_FLAG)
+    cdef tuple ops = (receive_op,)
+    try:
+        await execute_batch(grpc_call_wrapper, ops, loop)
+    except ExecuteBatchError as e:
+        # NOTE(lidiz) The receive message operation has two ways to indicate
+        # finish state : 1) returns empty message due to EOF; 2) fails inside
+        # the callback (e.g. cancelled).
+        #
+        # Since they all indicates finish, they are better be merged.
+        _LOGGER.debug('Failed to receive any message from Core')
+    return receive_op.message()
+
+
+async def _send_message(GrpcCallWrapper grpc_call_wrapper,
+                        bytes message,
+                        Operation send_initial_metadata_op,
+                        int write_flag,
+                        object loop):
+    cdef SendMessageOperation op = SendMessageOperation(message, write_flag)
+    cdef tuple ops = (op,)
+    if send_initial_metadata_op is not None:
+        ops = (send_initial_metadata_op,) + ops
+    await execute_batch(grpc_call_wrapper, ops, loop)
+
+
+async def _send_initial_metadata(GrpcCallWrapper grpc_call_wrapper,
+                                 tuple metadata,
+                                 int flags,
+                                 object loop):
+    cdef SendInitialMetadataOperation op = SendInitialMetadataOperation(
+        metadata,
+        flags)
+    cdef tuple ops = (op,)
+    await execute_batch(grpc_call_wrapper, ops, loop)
+
+
+async def _receive_initial_metadata(GrpcCallWrapper grpc_call_wrapper,
+                                    object loop):
+    cdef ReceiveInitialMetadataOperation op = ReceiveInitialMetadataOperation(_EMPTY_FLAGS)
+    cdef tuple ops = (op,)
+    await execute_batch(grpc_call_wrapper, ops, loop)
+    return op.initial_metadata()
+
+async def _send_error_status_from_server(GrpcCallWrapper grpc_call_wrapper,
+                                         grpc_status_code code,
+                                         str details,
+                                         tuple trailing_metadata,
+                                         Operation send_initial_metadata_op,
+                                         object loop):
+    assert code != StatusCode.ok, 'Expecting non-ok status code.'
+    cdef SendStatusFromServerOperation op = SendStatusFromServerOperation(
+        trailing_metadata,
+        code,
+        details,
+        _EMPTY_FLAGS,
+    )
+    cdef tuple ops = (op,)
+    if send_initial_metadata_op is not None:
+        ops = (send_initial_metadata_op,) + ops
+    await execute_batch(grpc_call_wrapper, ops, loop)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/channel.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/channel.pxd.pxi
index 99c5fa2123..03b4990e48 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/channel.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/channel.pxd.pxi
@@ -12,16 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-cdef enum AioChannelStatus: 
-    AIO_CHANNEL_STATUS_UNKNOWN 
-    AIO_CHANNEL_STATUS_READY 
-    AIO_CHANNEL_STATUS_CLOSING 
-    AIO_CHANNEL_STATUS_DESTROYED 
- 
+cdef enum AioChannelStatus:
+    AIO_CHANNEL_STATUS_UNKNOWN
+    AIO_CHANNEL_STATUS_READY
+    AIO_CHANNEL_STATUS_CLOSING
+    AIO_CHANNEL_STATUS_DESTROYED
+
 cdef class AioChannel:
     cdef:
         grpc_channel * channel
-        object loop 
+        object loop
         bytes _target
-        AioChannelStatus _status 
-        bint _is_secure 
+        AioChannelStatus _status
+        bint _is_secure
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/channel.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/channel.pyx.pxi
index 7b38743b6f..beadce67b4 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/channel.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/channel.pyx.pxi
@@ -11,124 +11,124 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# 
-
- 
-class _WatchConnectivityFailed(Exception): 
-    """Dedicated exception class for watch connectivity failed. 
- 
-    It might be failed due to deadline exceeded. 
-    """ 
-cdef CallbackFailureHandler _WATCH_CONNECTIVITY_FAILURE_HANDLER = CallbackFailureHandler( 
-    'watch_connectivity_state', 
-    'Timed out', 
-    _WatchConnectivityFailed) 
- 
- 
+#
+
+
+class _WatchConnectivityFailed(Exception):
+    """Dedicated exception class for watch connectivity failed.
+
+    It might be failed due to deadline exceeded.
+    """
+cdef CallbackFailureHandler _WATCH_CONNECTIVITY_FAILURE_HANDLER = CallbackFailureHandler(
+    'watch_connectivity_state',
+    'Timed out',
+    _WatchConnectivityFailed)
+
+
 cdef class AioChannel:
-    def __cinit__(self, bytes target, tuple options, ChannelCredentials credentials, object loop): 
-        init_grpc_aio() 
-        if options is None: 
-            options = () 
-        cdef _ChannelArgs channel_args = _ChannelArgs(options) 
-        self._target = target 
-        self.loop = loop 
-        self._status = AIO_CHANNEL_STATUS_READY 
-
-        if credentials is None: 
-            self._is_secure = False 
-            self.channel = grpc_insecure_channel_create( 
-                <char *>target, 
-                channel_args.c_args(), 
-                NULL) 
-        else: 
-            self._is_secure = True 
-            self.channel = grpc_secure_channel_create( 
-                <grpc_channel_credentials *> credentials.c(), 
-                <char *>target, 
-                channel_args.c_args(), 
-                NULL) 
- 
-    def __dealloc__(self): 
-        shutdown_grpc_aio() 
- 
+    def __cinit__(self, bytes target, tuple options, ChannelCredentials credentials, object loop):
+        init_grpc_aio()
+        if options is None:
+            options = ()
+        cdef _ChannelArgs channel_args = _ChannelArgs(options)
+        self._target = target
+        self.loop = loop
+        self._status = AIO_CHANNEL_STATUS_READY
+
+        if credentials is None:
+            self._is_secure = False
+            self.channel = grpc_insecure_channel_create(
+                <char *>target,
+                channel_args.c_args(),
+                NULL)
+        else:
+            self._is_secure = True
+            self.channel = grpc_secure_channel_create(
+                <grpc_channel_credentials *> credentials.c(),
+                <char *>target,
+                channel_args.c_args(),
+                NULL)
+
+    def __dealloc__(self):
+        shutdown_grpc_aio()
+
     def __repr__(self):
         class_name = self.__class__.__name__
         id_ = id(self)
         return f"<{class_name} {id_}>"
 
-    def check_connectivity_state(self, bint try_to_connect): 
-        """A Cython wrapper for Core's check connectivity state API.""" 
-        if self._status == AIO_CHANNEL_STATUS_DESTROYED: 
-            return ConnectivityState.shutdown 
-        else: 
-            return grpc_channel_check_connectivity_state( 
-                self.channel, 
-                try_to_connect, 
-            ) 
- 
-    async def watch_connectivity_state(self, 
-                                       grpc_connectivity_state last_observed_state, 
-                                       object deadline): 
-        """Watch for one connectivity state change. 
- 
-        Keeps mirroring the behavior from Core, so we can easily switch to 
-        other design of API if necessary. 
-        """ 
-        if self._status in (AIO_CHANNEL_STATUS_DESTROYED, AIO_CHANNEL_STATUS_CLOSING): 
-            raise UsageError('Channel is closed.') 
- 
-        cdef gpr_timespec c_deadline = _timespec_from_time(deadline) 
- 
-        cdef object future = self.loop.create_future() 
-        cdef CallbackWrapper wrapper = CallbackWrapper( 
-            future, 
-            self.loop, 
-            _WATCH_CONNECTIVITY_FAILURE_HANDLER) 
-        grpc_channel_watch_connectivity_state( 
-            self.channel, 
-            last_observed_state, 
-            c_deadline, 
-            global_completion_queue(), 
-            wrapper.c_functor()) 
- 
-        try: 
-            await future 
-        except _WatchConnectivityFailed: 
-            return False 
-        else: 
-            return True 
- 
-    def closing(self): 
-        self._status = AIO_CHANNEL_STATUS_CLOSING 
- 
+    def check_connectivity_state(self, bint try_to_connect):
+        """A Cython wrapper for Core's check connectivity state API."""
+        if self._status == AIO_CHANNEL_STATUS_DESTROYED:
+            return ConnectivityState.shutdown
+        else:
+            return grpc_channel_check_connectivity_state(
+                self.channel,
+                try_to_connect,
+            )
+
+    async def watch_connectivity_state(self,
+                                       grpc_connectivity_state last_observed_state,
+                                       object deadline):
+        """Watch for one connectivity state change.
+
+        Keeps mirroring the behavior from Core, so we can easily switch to
+        other design of API if necessary.
+        """
+        if self._status in (AIO_CHANNEL_STATUS_DESTROYED, AIO_CHANNEL_STATUS_CLOSING):
+            raise UsageError('Channel is closed.')
+
+        cdef gpr_timespec c_deadline = _timespec_from_time(deadline)
+
+        cdef object future = self.loop.create_future()
+        cdef CallbackWrapper wrapper = CallbackWrapper(
+            future,
+            self.loop,
+            _WATCH_CONNECTIVITY_FAILURE_HANDLER)
+        grpc_channel_watch_connectivity_state(
+            self.channel,
+            last_observed_state,
+            c_deadline,
+            global_completion_queue(),
+            wrapper.c_functor())
+
+        try:
+            await future
+        except _WatchConnectivityFailed:
+            return False
+        else:
+            return True
+
+    def closing(self):
+        self._status = AIO_CHANNEL_STATUS_CLOSING
+
     def close(self):
-        self._status = AIO_CHANNEL_STATUS_DESTROYED 
+        self._status = AIO_CHANNEL_STATUS_DESTROYED
         grpc_channel_destroy(self.channel)
 
-    def closed(self): 
-        return self._status in (AIO_CHANNEL_STATUS_CLOSING, AIO_CHANNEL_STATUS_DESTROYED) 
- 
-    def call(self, 
-             bytes method, 
-             object deadline, 
-             object python_call_credentials, 
-             object wait_for_ready): 
-        """Assembles a Cython Call object. 
- 
-        Returns: 
-          An _AioCall object. 
-        """ 
-        if self.closed(): 
-            raise UsageError('Channel is closed.') 
- 
-        cdef CallCredentials cython_call_credentials 
-        if python_call_credentials is not None: 
-            if not self._is_secure: 
-                raise UsageError("Call credentials are only valid on secure channels") 
- 
-            cython_call_credentials = python_call_credentials._credentials 
-        else: 
-            cython_call_credentials = None 
- 
-        return _AioCall(self, deadline, method, cython_call_credentials, wait_for_ready) 
+    def closed(self):
+        return self._status in (AIO_CHANNEL_STATUS_CLOSING, AIO_CHANNEL_STATUS_DESTROYED)
+
+    def call(self,
+             bytes method,
+             object deadline,
+             object python_call_credentials,
+             object wait_for_ready):
+        """Assembles a Cython Call object.
+
+        Returns:
+          An _AioCall object.
+        """
+        if self.closed():
+            raise UsageError('Channel is closed.')
+
+        cdef CallCredentials cython_call_credentials
+        if python_call_credentials is not None:
+            if not self._is_secure:
+                raise UsageError("Call credentials are only valid on secure channels")
+
+            cython_call_credentials = python_call_credentials._credentials
+        else:
+            cython_call_credentials = None
+
+        return _AioCall(self, deadline, method, cython_call_credentials, wait_for_ready)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/common.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/common.pyx.pxi
index 14cff6a2e9..f759fbbec0 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/common.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/common.pyx.pxi
@@ -1,186 +1,186 @@
-# Copyright 2019 The gRPC Authors 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
- 
-from cpython.version cimport PY_MAJOR_VERSION, PY_MINOR_VERSION 
- 
- 
-cdef grpc_status_code get_status_code(object code) except *: 
-    if isinstance(code, int): 
-        if code >= StatusCode.ok and code <= StatusCode.data_loss: 
-            return code 
-        else: 
-            return StatusCode.unknown 
-    else: 
-        try: 
-            return code.value[0] 
-        except (KeyError, AttributeError): 
-            return StatusCode.unknown 
- 
- 
-cdef object deserialize(object deserializer, bytes raw_message): 
-    """Perform deserialization on raw bytes. 
- 
-    Failure to deserialize is a fatal error. 
-    """ 
-    if deserializer: 
-        return deserializer(raw_message) 
-    else: 
-        return raw_message 
- 
- 
-cdef bytes serialize(object serializer, object message): 
-    """Perform serialization on a message. 
- 
-    Failure to serialize is a fatal error. 
-    """ 
-    if isinstance(message, str): 
-        message = message.encode('utf-8') 
-    if serializer: 
-        return serializer(message) 
-    else: 
-        return message 
- 
- 
-class _EOF: 
- 
-    def __bool__(self): 
-        return False 
-     
-    def __len__(self): 
-        return 0 
- 
-    def _repr(self) -> str: 
-        return '<grpc.aio.EOF>' 
- 
-    def __repr__(self) -> str: 
-        return self._repr() 
- 
-    def __str__(self) -> str: 
-        return self._repr() 
- 
- 
-EOF = _EOF() 
- 
-_COMPRESSION_METADATA_STRING_MAPPING = { 
-    CompressionAlgorithm.none: 'identity', 
-    CompressionAlgorithm.deflate: 'deflate', 
-    CompressionAlgorithm.gzip: 'gzip', 
-} 
- 
-class BaseError(Exception): 
-    """The base class for exceptions generated by gRPC AsyncIO stack.""" 
- 
- 
-class UsageError(BaseError): 
-    """Raised when the usage of API by applications is inappropriate. 
- 
-    For example, trying to invoke RPC on a closed channel, mixing two styles 
-    of streaming API on the client side. This exception should not be 
-    suppressed. 
-    """ 
- 
- 
-class AbortError(BaseError): 
-    """Raised when calling abort in servicer methods. 
- 
-    This exception should not be suppressed. Applications may catch it to 
-    perform certain clean-up logic, and then re-raise it. 
-    """ 
- 
- 
-class InternalError(BaseError): 
-    """Raised upon unexpected errors in native code.""" 
- 
- 
-def schedule_coro_threadsafe(object coro, object loop): 
-    try: 
-        return loop.create_task(coro) 
-    except RuntimeError as runtime_error: 
-        if 'Non-thread-safe operation' in str(runtime_error): 
-            return asyncio.run_coroutine_threadsafe( 
-                coro, 
-                loop, 
-            ) 
-        else: 
-            raise 
- 
- 
-def async_generator_to_generator(object agen, object loop): 
-    """Converts an async generator into generator.""" 
-    try: 
-        while True: 
-            future = asyncio.run_coroutine_threadsafe( 
-                agen.__anext__(), 
-                loop 
-            ) 
-            response = future.result() 
-            if response is EOF: 
-                break 
-            else: 
-                yield response 
-    except StopAsyncIteration: 
-        # If StopAsyncIteration is raised, end this generator. 
-        pass 
- 
- 
-async def generator_to_async_generator(object gen, object loop, object thread_pool): 
-    """Converts a generator into async generator. 
- 
-    The generator might block, so we need to delegate the iteration to thread 
-    pool. Also, we can't simply delegate __next__ to the thread pool, otherwise 
-    we will see following error: 
- 
-        TypeError: StopIteration interacts badly with generators and cannot be 
-            raised into a Future 
-    """ 
-    queue = asyncio.Queue(maxsize=1, loop=loop) 
- 
-    def yield_to_queue(): 
-        try: 
-            for item in gen: 
-                asyncio.run_coroutine_threadsafe(queue.put(item), loop).result() 
-        finally: 
-            asyncio.run_coroutine_threadsafe(queue.put(EOF), loop).result() 
- 
-    future = loop.run_in_executor( 
-        thread_pool, 
-        yield_to_queue, 
-    ) 
- 
-    while True: 
-        response = await queue.get() 
-        if response is EOF: 
-            break 
-        else: 
-            yield response 
- 
-    # Port the exception if there is any 
-    await future 
- 
- 
-if PY_MAJOR_VERSION >= 3 and PY_MINOR_VERSION >= 7: 
-    def get_working_loop(): 
-        """Returns a running event loop. 
- 
-        Due to a defect of asyncio.get_event_loop, its returned event loop might 
-        not be set as the default event loop for the main thread. 
-        """ 
-        try: 
-            return asyncio.get_running_loop() 
-        except RuntimeError: 
-            return asyncio.get_event_loop() 
-else: 
-    def get_working_loop(): 
-        """Returns a running event loop.""" 
-        return asyncio.get_event_loop() 
+# Copyright 2019 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cpython.version cimport PY_MAJOR_VERSION, PY_MINOR_VERSION
+
+
+cdef grpc_status_code get_status_code(object code) except *:
+    if isinstance(code, int):
+        if code >= StatusCode.ok and code <= StatusCode.data_loss:
+            return code
+        else:
+            return StatusCode.unknown
+    else:
+        try:
+            return code.value[0]
+        except (KeyError, AttributeError):
+            return StatusCode.unknown
+
+
+cdef object deserialize(object deserializer, bytes raw_message):
+    """Perform deserialization on raw bytes.
+
+    Failure to deserialize is a fatal error.
+    """
+    if deserializer:
+        return deserializer(raw_message)
+    else:
+        return raw_message
+
+
+cdef bytes serialize(object serializer, object message):
+    """Perform serialization on a message.
+
+    Failure to serialize is a fatal error.
+    """
+    if isinstance(message, str):
+        message = message.encode('utf-8')
+    if serializer:
+        return serializer(message)
+    else:
+        return message
+
+
+class _EOF:
+
+    def __bool__(self):
+        return False
+    
+    def __len__(self):
+        return 0
+
+    def _repr(self) -> str:
+        return '<grpc.aio.EOF>'
+
+    def __repr__(self) -> str:
+        return self._repr()
+
+    def __str__(self) -> str:
+        return self._repr()
+
+
+EOF = _EOF()
+
+_COMPRESSION_METADATA_STRING_MAPPING = {
+    CompressionAlgorithm.none: 'identity',
+    CompressionAlgorithm.deflate: 'deflate',
+    CompressionAlgorithm.gzip: 'gzip',
+}
+
+class BaseError(Exception):
+    """The base class for exceptions generated by gRPC AsyncIO stack."""
+
+
+class UsageError(BaseError):
+    """Raised when the usage of API by applications is inappropriate.
+
+    For example, trying to invoke RPC on a closed channel, mixing two styles
+    of streaming API on the client side. This exception should not be
+    suppressed.
+    """
+
+
+class AbortError(BaseError):
+    """Raised when calling abort in servicer methods.
+
+    This exception should not be suppressed. Applications may catch it to
+    perform certain clean-up logic, and then re-raise it.
+    """
+
+
+class InternalError(BaseError):
+    """Raised upon unexpected errors in native code."""
+
+
+def schedule_coro_threadsafe(object coro, object loop):
+    try:
+        return loop.create_task(coro)
+    except RuntimeError as runtime_error:
+        if 'Non-thread-safe operation' in str(runtime_error):
+            return asyncio.run_coroutine_threadsafe(
+                coro,
+                loop,
+            )
+        else:
+            raise
+
+
+def async_generator_to_generator(object agen, object loop):
+    """Converts an async generator into generator."""
+    try:
+        while True:
+            future = asyncio.run_coroutine_threadsafe(
+                agen.__anext__(),
+                loop
+            )
+            response = future.result()
+            if response is EOF:
+                break
+            else:
+                yield response
+    except StopAsyncIteration:
+        # If StopAsyncIteration is raised, end this generator.
+        pass
+
+
+async def generator_to_async_generator(object gen, object loop, object thread_pool):
+    """Converts a generator into async generator.
+
+    The generator might block, so we need to delegate the iteration to thread
+    pool. Also, we can't simply delegate __next__ to the thread pool, otherwise
+    we will see following error:
+
+        TypeError: StopIteration interacts badly with generators and cannot be
+            raised into a Future
+    """
+    queue = asyncio.Queue(maxsize=1, loop=loop)
+
+    def yield_to_queue():
+        try:
+            for item in gen:
+                asyncio.run_coroutine_threadsafe(queue.put(item), loop).result()
+        finally:
+            asyncio.run_coroutine_threadsafe(queue.put(EOF), loop).result()
+
+    future = loop.run_in_executor(
+        thread_pool,
+        yield_to_queue,
+    )
+
+    while True:
+        response = await queue.get()
+        if response is EOF:
+            break
+        else:
+            yield response
+
+    # Port the exception if there is any
+    await future
+
+
+if PY_MAJOR_VERSION >= 3 and PY_MINOR_VERSION >= 7:
+    def get_working_loop():
+        """Returns a running event loop.
+
+        Due to a defect of asyncio.get_event_loop, its returned event loop might
+        not be set as the default event loop for the main thread.
+        """
+        try:
+            return asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.get_event_loop()
+else:
+    def get_working_loop():
+        """Returns a running event loop."""
+        return asyncio.get_event_loop()
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pxd.pxi
index dea39759f1..a5189ad526 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pxd.pxi
@@ -1,76 +1,76 @@
-# Copyright 2020 The gRPC Authors 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
- 
-# NOTE(lidiz) Unfortunately, we can't use "cimport" here because Cython 
-# links it with exception handling. It introduces new dependencies. 
-cdef extern from "<queue>" namespace "std" nogil: 
-    cdef cppclass queue[T]: 
-        queue() 
-        bint empty() 
-        T& front() 
-        void pop() 
-        void push(T&) 
-        size_t size() 
- 
- 
-cdef extern from "<mutex>" namespace "std" nogil: 
-    cdef cppclass mutex: 
-        mutex() 
-        void lock() 
-        void unlock() 
- 
- 
-ctypedef queue[grpc_event] cpp_event_queue 
- 
- 
-IF UNAME_SYSNAME == "Windows": 
-    cdef extern from "winsock2.h" nogil: 
-        ctypedef uint32_t WIN_SOCKET "SOCKET" 
-        WIN_SOCKET win_socket "socket" (int af, int type, int protocol) 
-        int win_socket_send "send" (WIN_SOCKET s, const char *buf, int len, int flags) 
- 
- 
-cdef void _unified_socket_write(int fd) nogil 
- 
- 
-cdef class BaseCompletionQueue: 
-    cdef grpc_completion_queue *_cq 
- 
-    cdef grpc_completion_queue* c_ptr(self) 
- 
- 
-cdef class _BoundEventLoop: 
-    cdef readonly object loop 
-    cdef readonly object read_socket  # socket.socket 
-    cdef bint _has_reader 
- 
- 
-cdef class PollerCompletionQueue(BaseCompletionQueue): 
-    cdef bint _shutdown 
-    cdef cpp_event_queue _queue 
-    cdef mutex _queue_mutex 
-    cdef object _poller_thread  # threading.Thread 
-    cdef int _write_fd 
-    cdef object _read_socket    # socket.socket 
-    cdef object _write_socket   # socket.socket 
-    cdef dict _loops            # Mapping[asyncio.AbstractLoop, _BoundEventLoop] 
- 
-    cdef void _poll(self) nogil 
-    cdef shutdown(self) 
- 
- 
-cdef class CallbackCompletionQueue(BaseCompletionQueue): 
-    cdef object _shutdown_completed  # asyncio.Future 
-    cdef CallbackWrapper _wrapper 
-    cdef object _loop 
+# Copyright 2020 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# NOTE(lidiz) Unfortunately, we can't use "cimport" here because Cython
+# links it with exception handling. It introduces new dependencies.
+cdef extern from "<queue>" namespace "std" nogil:
+    cdef cppclass queue[T]:
+        queue()
+        bint empty()
+        T& front()
+        void pop()
+        void push(T&)
+        size_t size()
+
+
+cdef extern from "<mutex>" namespace "std" nogil:
+    cdef cppclass mutex:
+        mutex()
+        void lock()
+        void unlock()
+
+
+ctypedef queue[grpc_event] cpp_event_queue
+
+
+IF UNAME_SYSNAME == "Windows":
+    cdef extern from "winsock2.h" nogil:
+        ctypedef uint32_t WIN_SOCKET "SOCKET"
+        WIN_SOCKET win_socket "socket" (int af, int type, int protocol)
+        int win_socket_send "send" (WIN_SOCKET s, const char *buf, int len, int flags)
+
+
+cdef void _unified_socket_write(int fd) nogil
+
+
+cdef class BaseCompletionQueue:
+    cdef grpc_completion_queue *_cq
+
+    cdef grpc_completion_queue* c_ptr(self)
+
+
+cdef class _BoundEventLoop:
+    cdef readonly object loop
+    cdef readonly object read_socket  # socket.socket
+    cdef bint _has_reader
+
+
+cdef class PollerCompletionQueue(BaseCompletionQueue):
+    cdef bint _shutdown
+    cdef cpp_event_queue _queue
+    cdef mutex _queue_mutex
+    cdef object _poller_thread  # threading.Thread
+    cdef int _write_fd
+    cdef object _read_socket    # socket.socket
+    cdef object _write_socket   # socket.socket
+    cdef dict _loops            # Mapping[asyncio.AbstractLoop, _BoundEventLoop]
+
+    cdef void _poll(self) nogil
+    cdef shutdown(self)
+
+
+cdef class CallbackCompletionQueue(BaseCompletionQueue):
+    cdef object _shutdown_completed  # asyncio.Future
+    cdef CallbackWrapper _wrapper
+    cdef object _loop
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pyx.pxi
index 82ef11d0c9..1a32a55350 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pyx.pxi
@@ -1,194 +1,194 @@
-# Copyright 2020 The gRPC Authors 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
- 
-import socket 
- 
-cdef gpr_timespec _GPR_INF_FUTURE = gpr_inf_future(GPR_CLOCK_REALTIME) 
-cdef float _POLL_AWAKE_INTERVAL_S = 0.2 
- 
-# This bool indicates if the event loop impl can monitor a given fd, or has 
-# loop.add_reader method. 
-cdef bint _has_fd_monitoring = True 
- 
-IF UNAME_SYSNAME == "Windows": 
-    cdef void _unified_socket_write(int fd) nogil: 
-        win_socket_send(<WIN_SOCKET>fd, b"1", 1, 0) 
-ELSE: 
-    cimport posix.unistd as unistd 
- 
-    cdef void _unified_socket_write(int fd) nogil: 
-        unistd.write(fd, b"1", 1) 
- 
- 
-def _handle_callback_wrapper(CallbackWrapper callback_wrapper, int success): 
-    CallbackWrapper.functor_run(callback_wrapper.c_functor(), success) 
- 
- 
-cdef class BaseCompletionQueue: 
- 
-    cdef grpc_completion_queue* c_ptr(self): 
-        return self._cq 
- 
- 
-cdef class _BoundEventLoop: 
- 
-    def __cinit__(self, object loop, object read_socket, object handler): 
-        global _has_fd_monitoring 
-        self.loop = loop 
-        self.read_socket = read_socket 
-        reader_function = functools.partial( 
-            handler, 
-            loop 
-        ) 
-        # NOTE(lidiz) There isn't a way to cleanly pre-check if fd monitoring 
-        # support is available or not. Checking the event loop policy is not 
-        # good enough. The application can has its own loop implementation, or 
-        # uses different types of event loops (e.g., 1 Proactor, 3 Selectors). 
-        if _has_fd_monitoring: 
-            try: 
-                self.loop.add_reader(self.read_socket, reader_function) 
-                self._has_reader = True 
-            except NotImplementedError: 
-                _has_fd_monitoring = False 
-                self._has_reader = False 
- 
-    def close(self): 
-        if self.loop: 
-            if self._has_reader: 
-                self.loop.remove_reader(self.read_socket) 
- 
- 
-cdef class PollerCompletionQueue(BaseCompletionQueue): 
- 
-    def __cinit__(self): 
-        self._cq = grpc_completion_queue_create_for_next(NULL) 
-        self._shutdown = False 
-        self._poller_thread = threading.Thread(target=self._poll_wrapper, daemon=True) 
-        self._poller_thread.start() 
- 
-        self._read_socket, self._write_socket = socket.socketpair() 
-        self._write_fd = self._write_socket.fileno() 
-        self._loops = {} 
- 
-        # The read socket might be read by multiple threads. But only one of them will 
-        # read the 1 byte sent by the poller thread. This setting is essential to allow 
-        # multiple loops in multiple threads bound to the same poller. 
-        self._read_socket.setblocking(False) 
- 
-        self._queue = cpp_event_queue() 
- 
-    def bind_loop(self, object loop): 
-        if loop in self._loops: 
-            return 
-        else: 
-            self._loops[loop] = _BoundEventLoop(loop, self._read_socket, self._handle_events) 
- 
-    cdef void _poll(self) nogil: 
-        cdef grpc_event event 
-        cdef CallbackContext *context 
- 
-        while not self._shutdown: 
-            event = grpc_completion_queue_next(self._cq, 
-                                               _GPR_INF_FUTURE, 
-                                               NULL) 
- 
-            if event.type == GRPC_QUEUE_TIMEOUT: 
-                with gil: 
-                    raise AssertionError("Core should not return GRPC_QUEUE_TIMEOUT!") 
-            elif event.type == GRPC_QUEUE_SHUTDOWN: 
-                self._shutdown = True 
-            else: 
-                self._queue_mutex.lock() 
-                self._queue.push(event) 
-                self._queue_mutex.unlock() 
-                if _has_fd_monitoring: 
-                    _unified_socket_write(self._write_fd) 
-                else: 
-                    with gil: 
-                        # Event loops can be paused or killed at any time. So, 
-                        # instead of deligate to any thread, the polling thread 
-                        # should handle the distribution of the event. 
-                        self._handle_events(None) 
- 
-    def _poll_wrapper(self): 
-        with nogil: 
-            self._poll() 
- 
-    cdef shutdown(self): 
-        # Removes the socket hook from loops 
-        for loop in self._loops: 
-            self._loops.get(loop).close() 
- 
-        # TODO(https://github.com/grpc/grpc/issues/22365) perform graceful shutdown 
-        grpc_completion_queue_shutdown(self._cq) 
-        while not self._shutdown: 
-            self._poller_thread.join(timeout=_POLL_AWAKE_INTERVAL_S) 
-        grpc_completion_queue_destroy(self._cq) 
- 
-        # Clean up socket resources 
-        self._read_socket.close() 
-        self._write_socket.close() 
- 
-    def _handle_events(self, object context_loop): 
-        cdef bytes data 
-        if _has_fd_monitoring: 
-            # If fd monitoring is working, clean the socket without blocking. 
-            data = self._read_socket.recv(1) 
-        cdef grpc_event event 
-        cdef CallbackContext *context 
- 
-        while True: 
-            self._queue_mutex.lock() 
-            if self._queue.empty(): 
-                self._queue_mutex.unlock() 
-                break 
-            else: 
-                event = self._queue.front() 
-                self._queue.pop() 
-                self._queue_mutex.unlock() 
- 
-            context = <CallbackContext *>event.tag 
-            loop = <object>context.loop 
-            if loop is context_loop: 
-                # Executes callbacks: complete the future 
-                CallbackWrapper.functor_run( 
-                    <grpc_experimental_completion_queue_functor *>event.tag, 
-                    event.success 
-                ) 
-            else: 
-                loop.call_soon_threadsafe( 
-                    _handle_callback_wrapper, 
-                    <CallbackWrapper>context.callback_wrapper, 
-                    event.success 
-                ) 
- 
- 
-cdef class CallbackCompletionQueue(BaseCompletionQueue): 
- 
-    def __cinit__(self): 
-        self._loop = get_working_loop() 
-        self._shutdown_completed = self._loop.create_future() 
-        self._wrapper = CallbackWrapper( 
-            self._shutdown_completed, 
-            self._loop, 
-            CQ_SHUTDOWN_FAILURE_HANDLER) 
-        self._cq = grpc_completion_queue_create_for_callback( 
-            self._wrapper.c_functor(), 
-            NULL 
-        ) 
- 
-    async def shutdown(self): 
-        grpc_completion_queue_shutdown(self._cq) 
-        await self._shutdown_completed 
-        grpc_completion_queue_destroy(self._cq) 
+# Copyright 2020 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import socket
+
+cdef gpr_timespec _GPR_INF_FUTURE = gpr_inf_future(GPR_CLOCK_REALTIME)
+cdef float _POLL_AWAKE_INTERVAL_S = 0.2
+
+# This bool indicates if the event loop impl can monitor a given fd, or has
+# loop.add_reader method.
+cdef bint _has_fd_monitoring = True
+
+IF UNAME_SYSNAME == "Windows":
+    cdef void _unified_socket_write(int fd) nogil:
+        win_socket_send(<WIN_SOCKET>fd, b"1", 1, 0)
+ELSE:
+    cimport posix.unistd as unistd
+
+    cdef void _unified_socket_write(int fd) nogil:
+        unistd.write(fd, b"1", 1)
+
+
+def _handle_callback_wrapper(CallbackWrapper callback_wrapper, int success):
+    CallbackWrapper.functor_run(callback_wrapper.c_functor(), success)
+
+
+cdef class BaseCompletionQueue:
+
+    cdef grpc_completion_queue* c_ptr(self):
+        return self._cq
+
+
+cdef class _BoundEventLoop:
+
+    def __cinit__(self, object loop, object read_socket, object handler):
+        global _has_fd_monitoring
+        self.loop = loop
+        self.read_socket = read_socket
+        reader_function = functools.partial(
+            handler,
+            loop
+        )
+        # NOTE(lidiz) There isn't a way to cleanly pre-check if fd monitoring
+        # support is available or not. Checking the event loop policy is not
+        # good enough. The application can has its own loop implementation, or
+        # uses different types of event loops (e.g., 1 Proactor, 3 Selectors).
+        if _has_fd_monitoring:
+            try:
+                self.loop.add_reader(self.read_socket, reader_function)
+                self._has_reader = True
+            except NotImplementedError:
+                _has_fd_monitoring = False
+                self._has_reader = False
+
+    def close(self):
+        if self.loop:
+            if self._has_reader:
+                self.loop.remove_reader(self.read_socket)
+
+
+cdef class PollerCompletionQueue(BaseCompletionQueue):
+
+    def __cinit__(self):
+        self._cq = grpc_completion_queue_create_for_next(NULL)
+        self._shutdown = False
+        self._poller_thread = threading.Thread(target=self._poll_wrapper, daemon=True)
+        self._poller_thread.start()
+
+        self._read_socket, self._write_socket = socket.socketpair()
+        self._write_fd = self._write_socket.fileno()
+        self._loops = {}
+
+        # The read socket might be read by multiple threads. But only one of them will
+        # read the 1 byte sent by the poller thread. This setting is essential to allow
+        # multiple loops in multiple threads bound to the same poller.
+        self._read_socket.setblocking(False)
+
+        self._queue = cpp_event_queue()
+
+    def bind_loop(self, object loop):
+        if loop in self._loops:
+            return
+        else:
+            self._loops[loop] = _BoundEventLoop(loop, self._read_socket, self._handle_events)
+
+    cdef void _poll(self) nogil:
+        cdef grpc_event event
+        cdef CallbackContext *context
+
+        while not self._shutdown:
+            event = grpc_completion_queue_next(self._cq,
+                                               _GPR_INF_FUTURE,
+                                               NULL)
+
+            if event.type == GRPC_QUEUE_TIMEOUT:
+                with gil:
+                    raise AssertionError("Core should not return GRPC_QUEUE_TIMEOUT!")
+            elif event.type == GRPC_QUEUE_SHUTDOWN:
+                self._shutdown = True
+            else:
+                self._queue_mutex.lock()
+                self._queue.push(event)
+                self._queue_mutex.unlock()
+                if _has_fd_monitoring:
+                    _unified_socket_write(self._write_fd)
+                else:
+                    with gil:
+                        # Event loops can be paused or killed at any time. So,
+                        # instead of deligate to any thread, the polling thread
+                        # should handle the distribution of the event.
+                        self._handle_events(None)
+
+    def _poll_wrapper(self):
+        with nogil:
+            self._poll()
+
+    cdef shutdown(self):
+        # Removes the socket hook from loops
+        for loop in self._loops:
+            self._loops.get(loop).close()
+
+        # TODO(https://github.com/grpc/grpc/issues/22365) perform graceful shutdown
+        grpc_completion_queue_shutdown(self._cq)
+        while not self._shutdown:
+            self._poller_thread.join(timeout=_POLL_AWAKE_INTERVAL_S)
+        grpc_completion_queue_destroy(self._cq)
+
+        # Clean up socket resources
+        self._read_socket.close()
+        self._write_socket.close()
+
+    def _handle_events(self, object context_loop):
+        cdef bytes data
+        if _has_fd_monitoring:
+            # If fd monitoring is working, clean the socket without blocking.
+            data = self._read_socket.recv(1)
+        cdef grpc_event event
+        cdef CallbackContext *context
+
+        while True:
+            self._queue_mutex.lock()
+            if self._queue.empty():
+                self._queue_mutex.unlock()
+                break
+            else:
+                event = self._queue.front()
+                self._queue.pop()
+                self._queue_mutex.unlock()
+
+            context = <CallbackContext *>event.tag
+            loop = <object>context.loop
+            if loop is context_loop:
+                # Executes callbacks: complete the future
+                CallbackWrapper.functor_run(
+                    <grpc_experimental_completion_queue_functor *>event.tag,
+                    event.success
+                )
+            else:
+                loop.call_soon_threadsafe(
+                    _handle_callback_wrapper,
+                    <CallbackWrapper>context.callback_wrapper,
+                    event.success
+                )
+
+
+cdef class CallbackCompletionQueue(BaseCompletionQueue):
+
+    def __cinit__(self):
+        self._loop = get_working_loop()
+        self._shutdown_completed = self._loop.create_future()
+        self._wrapper = CallbackWrapper(
+            self._shutdown_completed,
+            self._loop,
+            CQ_SHUTDOWN_FAILURE_HANDLER)
+        self._cq = grpc_completion_queue_create_for_callback(
+            self._wrapper.c_functor(),
+            NULL
+        )
+
+    async def shutdown(self):
+        grpc_completion_queue_shutdown(self._cq)
+        await self._shutdown_completed
+        grpc_completion_queue_destroy(self._cq)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pxd.pxi
index 5c1c67d86e..ebf0660174 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pxd.pxi
@@ -13,31 +13,31 @@
 # limitations under the License.
 # distutils: language=c++
 
-cdef class _AioState: 
-    cdef object lock  # threading.RLock 
-    cdef int refcount 
-    cdef object engine  # AsyncIOEngine 
-    cdef BaseCompletionQueue cq 
- 
- 
-cdef grpc_completion_queue *global_completion_queue() 
- 
- 
-cpdef init_grpc_aio() 
- 
- 
-cpdef shutdown_grpc_aio() 
- 
- 
+cdef class _AioState:
+    cdef object lock  # threading.RLock
+    cdef int refcount
+    cdef object engine  # AsyncIOEngine
+    cdef BaseCompletionQueue cq
+
+
+cdef grpc_completion_queue *global_completion_queue()
+
+
+cpdef init_grpc_aio()
+
+
+cpdef shutdown_grpc_aio()
+
+
 cdef extern from "src/core/lib/iomgr/timer_manager.h":
-  void grpc_timer_manager_set_threading(bint enabled) 
+  void grpc_timer_manager_set_threading(bint enabled)
+
 
- 
 cdef extern from "src/core/lib/iomgr/iomgr_internal.h":
-  void grpc_set_default_iomgr_platform() 
+  void grpc_set_default_iomgr_platform()
+
 
- 
 cdef extern from "src/core/lib/iomgr/executor.h" namespace "grpc_core":
     cdef cppclass Executor:
         @staticmethod
-        void SetThreadingAll(bint enable) 
+        void SetThreadingAll(bint enable)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pyx.pxi
index 8b829e85cc..06c92cac58 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/grpc_aio.pyx.pxi
@@ -12,132 +12,132 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import enum 
-
-cdef str _GRPC_ASYNCIO_ENGINE = os.environ.get('GRPC_ASYNCIO_ENGINE', 'poller').upper() 
-cdef _AioState _global_aio_state = _AioState() 
-
-
-class AsyncIOEngine(enum.Enum): 
-    CUSTOM_IO_MANAGER = 'custom_io_manager' 
-    POLLER = 'poller' 
-
-
-cdef _default_asyncio_engine(): 
-    return AsyncIOEngine.POLLER 
- 
- 
-cdef grpc_completion_queue *global_completion_queue(): 
-    return _global_aio_state.cq.c_ptr() 
- 
- 
-cdef class _AioState: 
- 
-    def __cinit__(self): 
-        self.lock = threading.RLock() 
-        self.refcount = 0 
-        self.engine = None 
-        self.cq = None 
- 
- 
-cdef _initialize_custom_io_manager(): 
-    # Activates asyncio IO manager. 
-    # NOTE(lidiz) Custom IO manager must be activated before the first 
-    # `grpc_init()`. Otherwise, some special configurations in Core won't 
-    # pick up the change, and resulted in SEGFAULT or ABORT. 
+import enum
+
+cdef str _GRPC_ASYNCIO_ENGINE = os.environ.get('GRPC_ASYNCIO_ENGINE', 'poller').upper()
+cdef _AioState _global_aio_state = _AioState()
+
+
+class AsyncIOEngine(enum.Enum):
+    CUSTOM_IO_MANAGER = 'custom_io_manager'
+    POLLER = 'poller'
+
+
+cdef _default_asyncio_engine():
+    return AsyncIOEngine.POLLER
+
+
+cdef grpc_completion_queue *global_completion_queue():
+    return _global_aio_state.cq.c_ptr()
+
+
+cdef class _AioState:
+
+    def __cinit__(self):
+        self.lock = threading.RLock()
+        self.refcount = 0
+        self.engine = None
+        self.cq = None
+
+
+cdef _initialize_custom_io_manager():
+    # Activates asyncio IO manager.
+    # NOTE(lidiz) Custom IO manager must be activated before the first
+    # `grpc_init()`. Otherwise, some special configurations in Core won't
+    # pick up the change, and resulted in SEGFAULT or ABORT.
     install_asyncio_iomgr()
- 
-    # Initializes gRPC Core, must be called before other Core API 
+
+    # Initializes gRPC Core, must be called before other Core API
     grpc_init()
 
     # Timers are triggered by the Asyncio loop. We disable
     # the background thread that is being used by the native
     # gRPC iomgr.
-    grpc_timer_manager_set_threading(False) 
+    grpc_timer_manager_set_threading(False)
 
     # gRPC callbaks are executed within the same thread used by the Asyncio
     # event loop, as it is being done by the other Asyncio callbacks.
-    Executor.SetThreadingAll(False) 
-
-    # Creates the only completion queue 
-    _global_aio_state.cq = CallbackCompletionQueue() 
- 
- 
-cdef _initialize_poller(): 
-    # Initializes gRPC Core, must be called before other Core API 
-    grpc_init() 
- 
-    # Creates the only completion queue 
-    _global_aio_state.cq = PollerCompletionQueue() 
- 
- 
-cdef _actual_aio_initialization(): 
-    # Picks the engine for gRPC AsyncIO Stack 
-    _global_aio_state.engine = AsyncIOEngine.__members__.get( 
-        _GRPC_ASYNCIO_ENGINE, 
-        _default_asyncio_engine(), 
-    ) 
-    _LOGGER.debug('Using %s as I/O engine', _global_aio_state.engine) 
- 
-    # Initializes the process-level state accordingly 
-    if _global_aio_state.engine is AsyncIOEngine.CUSTOM_IO_MANAGER: 
-        _initialize_custom_io_manager() 
-    elif _global_aio_state.engine is AsyncIOEngine.POLLER: 
-        _initialize_poller() 
-    else: 
-        raise ValueError('Unsupported engine type [%s]' % _global_aio_state.engine) 
- 
- 
-def _grpc_shutdown_wrapper(_): 
-    """A thin Python wrapper of Core's shutdown function. 
- 
-    Define functions are not allowed in "cdef" functions, and Cython complains 
-    about a simple lambda with a C function. 
-    """ 
-    grpc_shutdown_blocking() 
- 
- 
-cdef _actual_aio_shutdown(): 
-    if _global_aio_state.engine is AsyncIOEngine.CUSTOM_IO_MANAGER: 
-        future = schedule_coro_threadsafe( 
-            _global_aio_state.cq.shutdown(), 
-            (<CallbackCompletionQueue>_global_aio_state.cq)._loop 
-        ) 
-        future.add_done_callback(_grpc_shutdown_wrapper) 
-    elif _global_aio_state.engine is AsyncIOEngine.POLLER: 
-        (<PollerCompletionQueue>_global_aio_state.cq).shutdown() 
-        grpc_shutdown_blocking() 
-    else: 
-        raise ValueError('Unsupported engine type [%s]' % _global_aio_state.engine) 
- 
- 
-cdef _initialize_per_loop(): 
-    cdef object loop = get_working_loop() 
-    if _global_aio_state.engine is AsyncIOEngine.POLLER: 
-        _global_aio_state.cq.bind_loop(loop) 
- 
- 
-cpdef init_grpc_aio(): 
-    """Initializes the gRPC AsyncIO module. 
- 
-    Expected to be invoked on critical class constructors. 
-    E.g., AioChannel, AioServer. 
-    """ 
-    with _global_aio_state.lock: 
-        _global_aio_state.refcount += 1 
-        if _global_aio_state.refcount == 1: 
-            _actual_aio_initialization() 
-        _initialize_per_loop() 
- 
- 
-cpdef shutdown_grpc_aio(): 
-    """Shuts down the gRPC AsyncIO module. 
- 
-    Expected to be invoked on critical class destructors. 
-    E.g., AioChannel, AioServer. 
-    """ 
-    with _global_aio_state.lock: 
-        assert _global_aio_state.refcount > 0 
-        _global_aio_state.refcount -= 1 
-        if not _global_aio_state.refcount: 
-            _actual_aio_shutdown() 
+    Executor.SetThreadingAll(False)
+
+    # Creates the only completion queue
+    _global_aio_state.cq = CallbackCompletionQueue()
+
+
+cdef _initialize_poller():
+    # Initializes gRPC Core, must be called before other Core API
+    grpc_init()
+
+    # Creates the only completion queue
+    _global_aio_state.cq = PollerCompletionQueue()
+
+
+cdef _actual_aio_initialization():
+    # Picks the engine for gRPC AsyncIO Stack
+    _global_aio_state.engine = AsyncIOEngine.__members__.get(
+        _GRPC_ASYNCIO_ENGINE,
+        _default_asyncio_engine(),
+    )
+    _LOGGER.debug('Using %s as I/O engine', _global_aio_state.engine)
+
+    # Initializes the process-level state accordingly
+    if _global_aio_state.engine is AsyncIOEngine.CUSTOM_IO_MANAGER:
+        _initialize_custom_io_manager()
+    elif _global_aio_state.engine is AsyncIOEngine.POLLER:
+        _initialize_poller()
+    else:
+        raise ValueError('Unsupported engine type [%s]' % _global_aio_state.engine)
+
+
+def _grpc_shutdown_wrapper(_):
+    """A thin Python wrapper of Core's shutdown function.
+
+    Define functions are not allowed in "cdef" functions, and Cython complains
+    about a simple lambda with a C function.
+    """
+    grpc_shutdown_blocking()
+
+
+cdef _actual_aio_shutdown():
+    if _global_aio_state.engine is AsyncIOEngine.CUSTOM_IO_MANAGER:
+        future = schedule_coro_threadsafe(
+            _global_aio_state.cq.shutdown(),
+            (<CallbackCompletionQueue>_global_aio_state.cq)._loop
+        )
+        future.add_done_callback(_grpc_shutdown_wrapper)
+    elif _global_aio_state.engine is AsyncIOEngine.POLLER:
+        (<PollerCompletionQueue>_global_aio_state.cq).shutdown()
+        grpc_shutdown_blocking()
+    else:
+        raise ValueError('Unsupported engine type [%s]' % _global_aio_state.engine)
+
+
+cdef _initialize_per_loop():
+    cdef object loop = get_working_loop()
+    if _global_aio_state.engine is AsyncIOEngine.POLLER:
+        _global_aio_state.cq.bind_loop(loop)
+
+
+cpdef init_grpc_aio():
+    """Initializes the gRPC AsyncIO module.
+
+    Expected to be invoked on critical class constructors.
+    E.g., AioChannel, AioServer.
+    """
+    with _global_aio_state.lock:
+        _global_aio_state.refcount += 1
+        if _global_aio_state.refcount == 1:
+            _actual_aio_initialization()
+        _initialize_per_loop()
+
+
+cpdef shutdown_grpc_aio():
+    """Shuts down the gRPC AsyncIO module.
+
+    Expected to be invoked on critical class destructors.
+    E.g., AioChannel, AioServer.
+    """
+    with _global_aio_state.lock:
+        assert _global_aio_state.refcount > 0
+        _global_aio_state.refcount -= 1
+        if not _global_aio_state.refcount:
+            _actual_aio_shutdown()
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/iomgr.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/iomgr.pyx.pxi
index e8654385ac..917ae24e11 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/iomgr.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/iomgr.pyx.pxi
@@ -13,8 +13,8 @@
 # limitations under the License.
 
 
-import platform 
- 
+import platform
+
 from cpython cimport Py_INCREF, Py_DECREF
 from libc cimport string
 
@@ -28,7 +28,7 @@ cdef grpc_socket_vtable asyncio_socket_vtable
 cdef grpc_custom_resolver_vtable asyncio_resolver_vtable
 cdef grpc_custom_timer_vtable asyncio_timer_vtable
 cdef grpc_custom_poller_vtable asyncio_pollset_vtable
-cdef bint so_reuse_port 
+cdef bint so_reuse_port
 
 
 cdef grpc_error* asyncio_socket_init(
@@ -123,14 +123,14 @@ cdef grpc_error* asyncio_socket_listen(grpc_custom_socket* grpc_socket) with gil
     return grpc_error_none()
 
 
-def _asyncio_apply_socket_options(object s, int flags): 
-    # Turn SO_REUSEADDR on for TCP sockets; if we want to support UDS, we will 
-    # need to update this function. 
+def _asyncio_apply_socket_options(object s, int flags):
+    # Turn SO_REUSEADDR on for TCP sockets; if we want to support UDS, we will
+    # need to update this function.
     s.setsockopt(native_socket.SOL_SOCKET, native_socket.SO_REUSEADDR, 1)
-    # SO_REUSEPORT only available in POSIX systems. 
-    if platform.system() != 'Windows': 
-        if GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT & flags: 
-            s.setsockopt(native_socket.SOL_SOCKET, native_socket.SO_REUSEPORT, 1) 
+    # SO_REUSEPORT only available in POSIX systems.
+    if platform.system() != 'Windows':
+        if GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT & flags:
+            s.setsockopt(native_socket.SOL_SOCKET, native_socket.SO_REUSEPORT, 1)
     s.setsockopt(native_socket.IPPROTO_TCP, native_socket.TCP_NODELAY, True)
 
 
@@ -147,10 +147,10 @@ cdef grpc_error* asyncio_socket_bind(
             family = native_socket.AF_INET
 
         socket = native_socket.socket(family=family)
-        _asyncio_apply_socket_options(socket, flags) 
+        _asyncio_apply_socket_options(socket, flags)
         socket.bind((host, port))
     except IOError as io_error:
-        socket.close() 
+        socket.close()
         return socket_error("bind", str(io_error))
     else:
         aio_socket = _AsyncioSocket.create_with_py_socket(grpc_socket, socket)
@@ -167,8 +167,8 @@ cdef void asyncio_socket_accept(
 
 
 cdef grpc_error* asyncio_resolve(
-        const char* host, 
-        const char* port, 
+        const char* host,
+        const char* port,
         grpc_resolved_addresses** res) with gil:
     result = native_socket.getaddrinfo(host, port)
     res[0] = tuples_to_resolvaddr(result)
@@ -176,8 +176,8 @@ cdef grpc_error* asyncio_resolve(
 
 cdef void asyncio_resolve_async(
         grpc_custom_resolver* grpc_resolver,
-        const char* host, 
-        const char* port) with gil: 
+        const char* host,
+        const char* port) with gil:
     resolver = _AsyncioResolver.create(grpc_resolver)
     resolver.resolve(host, port)
 
@@ -188,12 +188,12 @@ cdef void asyncio_timer_start(grpc_custom_timer* grpc_timer) with gil:
 
 
 cdef void asyncio_timer_stop(grpc_custom_timer* grpc_timer) with gil:
-    # TODO(https://github.com/grpc/grpc/issues/22278) remove this if condition 
-    if grpc_timer.timer == NULL: 
-        return 
-    else: 
-        timer = <_AsyncioTimer>grpc_timer.timer 
-        timer.stop() 
+    # TODO(https://github.com/grpc/grpc/issues/22278) remove this if condition
+    if grpc_timer.timer == NULL:
+        return
+    else:
+        timer = <_AsyncioTimer>grpc_timer.timer
+        timer.stop()
 
 
 cdef void asyncio_init_loop() with gil:
@@ -212,18 +212,18 @@ cdef void asyncio_run_loop(size_t timeout_ms) with gil:
     pass
 
 
-def _auth_plugin_callback_wrapper(object cb, 
-                                  str service_url, 
-                                  str method_name, 
-                                  object callback): 
-    get_working_loop().call_soon(cb, service_url, method_name, callback) 
- 
- 
+def _auth_plugin_callback_wrapper(object cb,
+                                  str service_url,
+                                  str method_name,
+                                  object callback):
+    get_working_loop().call_soon(cb, service_url, method_name, callback)
+
+
 def install_asyncio_iomgr():
-    # Auth plugins invoke user provided logic in another thread by default. We 
-    # need to override that behavior by registering the call to the event loop. 
-    set_async_callback_func(_auth_plugin_callback_wrapper) 
- 
+    # Auth plugins invoke user provided logic in another thread by default. We
+    # need to override that behavior by registering the call to the event loop.
+    set_async_callback_func(_auth_plugin_callback_wrapper)
+
     asyncio_resolver_vtable.resolve = asyncio_resolve
     asyncio_resolver_vtable.resolve_async = asyncio_resolve_async
 
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/resolver.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/resolver.pxd.pxi
index 878c457f6f..51730c1597 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/resolver.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/resolver.pxd.pxi
@@ -14,11 +14,11 @@
 
 cdef class _AsyncioResolver:
     cdef:
-        object _loop 
+        object _loop
         grpc_custom_resolver* _grpc_resolver
         object _task_resolve
 
     @staticmethod
     cdef _AsyncioResolver create(grpc_custom_resolver* grpc_resolver)
 
-    cdef void resolve(self, const char* host, const char* port) 
+    cdef void resolve(self, const char* host, const char* port)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/resolver.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/resolver.pyx.pxi
index d9cd8be720..1a2e244ff9 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/resolver.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/resolver.pyx.pxi
@@ -15,7 +15,7 @@
 
 cdef class _AsyncioResolver:
     def __cinit__(self):
-        self._loop = get_working_loop() 
+        self._loop = get_working_loop()
         self._grpc_resolver = NULL
         self._task_resolve = None
 
@@ -30,27 +30,27 @@ cdef class _AsyncioResolver:
         id_ = id(self)
         return f"<{class_name} {id_}>"
 
-    async def _async_resolve(self, bytes host, bytes port): 
-        self._task_resolve = None 
+    async def _async_resolve(self, bytes host, bytes port):
+        self._task_resolve = None
         try:
-            resolved = await self._loop.getaddrinfo(host, port) 
+            resolved = await self._loop.getaddrinfo(host, port)
         except Exception as e:
             grpc_custom_resolve_callback(
                 <grpc_custom_resolver*>self._grpc_resolver,
-                NULL, 
-                grpc_socket_error("Resolve address [{}:{}] failed: {}: {}".format( 
-                    host, port, type(e), str(e)).encode()) 
+                NULL,
+                grpc_socket_error("Resolve address [{}:{}] failed: {}: {}".format(
+                    host, port, type(e), str(e)).encode())
             )
         else:
             grpc_custom_resolve_callback(
                 <grpc_custom_resolver*>self._grpc_resolver,
-                tuples_to_resolvaddr(resolved), 
-                <grpc_error*>0 
+                tuples_to_resolvaddr(resolved),
+                <grpc_error*>0
             )
 
-    cdef void resolve(self, const char* host, const char* port): 
+    cdef void resolve(self, const char* host, const char* port):
         assert not self._task_resolve
 
-        self._task_resolve = self._loop.create_task( 
-            self._async_resolve(host, port) 
+        self._task_resolve = self._loop.create_task(
+            self._async_resolve(host, port)
         )
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/socket.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/socket.pxd.pxi
index 43a07c44aa..cfab5549b2 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/socket.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/socket.pxd.pxi
@@ -18,20 +18,20 @@ cdef class _AsyncioSocket:
         # Common attributes
         grpc_custom_socket * _grpc_socket
         grpc_custom_read_callback _grpc_read_cb
-        grpc_custom_write_callback _grpc_write_cb 
+        grpc_custom_write_callback _grpc_write_cb
         object _reader
         object _writer
         object _task_read
-        object _task_write 
+        object _task_write
         object _task_connect
-        object _task_listen 
+        object _task_listen
         char * _read_buffer
-        # Caches the picked event loop, so we can avoid the 30ns overhead each 
-        # time we need access to the event loop. 
-        object _loop 
-        # TODO(lidiz) Drop after 3.6 deprecation. Python 3.7 introduces methods 
-        # like `is_closing()` to help graceful shutdown. 
-        bint _closed 
+        # Caches the picked event loop, so we can avoid the 30ns overhead each
+        # time we need access to the event loop.
+        object _loop
+        # TODO(lidiz) Drop after 3.6 deprecation. Python 3.7 introduces methods
+        # like `is_closing()` to help graceful shutdown.
+        bint _closed
 
         # Client-side attributes
         grpc_custom_connect_callback _grpc_connect_cb
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/socket.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/socket.pyx.pxi
index 778a21e9fe..eecef17d98 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/socket.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/socket.pyx.pxi
@@ -16,28 +16,28 @@ import socket as native_socket
 
 from libc cimport string
 
-cdef int _ASYNCIO_STREAM_DEFAULT_SOCKET_BACKLOG = 100 
- 
- 
-# TODO(https://github.com/grpc/grpc/issues/21348) Better flow control needed. 
+cdef int _ASYNCIO_STREAM_DEFAULT_SOCKET_BACKLOG = 100
+
+
+# TODO(https://github.com/grpc/grpc/issues/21348) Better flow control needed.
 cdef class _AsyncioSocket:
     def __cinit__(self):
         self._grpc_socket = NULL
         self._grpc_connect_cb = NULL
         self._grpc_read_cb = NULL
-        self._grpc_write_cb = NULL 
+        self._grpc_write_cb = NULL
         self._reader = None
         self._writer = None
         self._task_connect = None
         self._task_read = None
-        self._task_write = None 
-        self._task_listen = None 
+        self._task_write = None
+        self._task_listen = None
         self._read_buffer = NULL
         self._server = None
         self._py_socket = None
         self._peername = None
-        self._closed = False 
-        self._loop = get_working_loop() 
+        self._closed = False
+        self._loop = get_working_loop()
 
     @staticmethod
     cdef _AsyncioSocket create(grpc_custom_socket * grpc_socket,
@@ -64,57 +64,57 @@ cdef class _AsyncioSocket:
         connected = self.is_connected()
         return f"<{class_name} {id_} connected={connected}>"
 
-    async def _async_connect(self, object host, object port,): 
-        self._task_connect = None 
+    async def _async_connect(self, object host, object port,):
+        self._task_connect = None
         try:
-            self._reader, self._writer = await asyncio.open_connection(host, port) 
+            self._reader, self._writer = await asyncio.open_connection(host, port)
         except Exception as e:
-            self._grpc_connect_cb( 
-                <grpc_custom_socket*>self._grpc_socket, 
-                grpc_socket_error("Socket connect failed: {}: {}".format(type(e), str(e)).encode()) 
-            ) 
-        else: 
-            # gRPC default posix implementation disables nagle 
-            # algorithm. 
-            sock = self._writer.transport.get_extra_info('socket') 
-            sock.setsockopt(native_socket.IPPROTO_TCP, native_socket.TCP_NODELAY, True) 
-
-            self._grpc_connect_cb( 
-                <grpc_custom_socket*>self._grpc_socket, 
-                <grpc_error*>0 
-            ) 
-
-    cdef void connect(self, 
-                      object host, 
-                      object port, 
-                      grpc_custom_connect_callback grpc_connect_cb): 
-        assert not self._reader 
-        assert not self._task_connect 
- 
-        self._task_connect = self._loop.create_task( 
-            self._async_connect(host, port) 
-        ) 
-        self._grpc_connect_cb = grpc_connect_cb 
-
-    async def _async_read(self, size_t length): 
-        self._task_read = None 
+            self._grpc_connect_cb(
+                <grpc_custom_socket*>self._grpc_socket,
+                grpc_socket_error("Socket connect failed: {}: {}".format(type(e), str(e)).encode())
+            )
+        else:
+            # gRPC default posix implementation disables nagle
+            # algorithm.
+            sock = self._writer.transport.get_extra_info('socket')
+            sock.setsockopt(native_socket.IPPROTO_TCP, native_socket.TCP_NODELAY, True)
+
+            self._grpc_connect_cb(
+                <grpc_custom_socket*>self._grpc_socket,
+                <grpc_error*>0
+            )
+
+    cdef void connect(self,
+                      object host,
+                      object port,
+                      grpc_custom_connect_callback grpc_connect_cb):
+        assert not self._reader
+        assert not self._task_connect
+
+        self._task_connect = self._loop.create_task(
+            self._async_connect(host, port)
+        )
+        self._grpc_connect_cb = grpc_connect_cb
+
+    async def _async_read(self, size_t length):
+        self._task_read = None
         try:
-            inbound_buffer = await self._reader.read(n=length) 
-        except ConnectionError as e: 
-            self._grpc_read_cb( 
-                <grpc_custom_socket*>self._grpc_socket, 
-                -1, 
-                grpc_socket_error("Read failed: {}".format(e).encode()) 
-            ) 
-        else: 
+            inbound_buffer = await self._reader.read(n=length)
+        except ConnectionError as e:
+            self._grpc_read_cb(
+                <grpc_custom_socket*>self._grpc_socket,
+                -1,
+                grpc_socket_error("Read failed: {}".format(e).encode())
+            )
+        else:
             string.memcpy(
                 <void*>self._read_buffer,
-                <char*>inbound_buffer, 
-                len(inbound_buffer) 
+                <char*>inbound_buffer,
+                len(inbound_buffer)
             )
             self._grpc_read_cb(
                 <grpc_custom_socket*>self._grpc_socket,
-                len(inbound_buffer), 
+                len(inbound_buffer),
                 <grpc_error*>0
             )
 
@@ -123,53 +123,53 @@ cdef class _AsyncioSocket:
 
         self._grpc_read_cb = grpc_read_cb
         self._read_buffer = buffer_
-        self._task_read = self._loop.create_task(self._async_read(length)) 
- 
-    async def _async_write(self, bytearray outbound_buffer): 
-        self._writer.write(outbound_buffer) 
-        self._task_write = None 
-        try: 
-            await self._writer.drain() 
-            self._grpc_write_cb( 
-                <grpc_custom_socket*>self._grpc_socket, 
-                <grpc_error*>0 
-            ) 
-        except ConnectionError as connection_error: 
-            self._grpc_write_cb( 
-                <grpc_custom_socket*>self._grpc_socket, 
-                grpc_socket_error("Socket write failed: {}".format(connection_error).encode()), 
-            ) 
- 
+        self._task_read = self._loop.create_task(self._async_read(length))
+
+    async def _async_write(self, bytearray outbound_buffer):
+        self._writer.write(outbound_buffer)
+        self._task_write = None
+        try:
+            await self._writer.drain()
+            self._grpc_write_cb(
+                <grpc_custom_socket*>self._grpc_socket,
+                <grpc_error*>0
+            )
+        except ConnectionError as connection_error:
+            self._grpc_write_cb(
+                <grpc_custom_socket*>self._grpc_socket,
+                grpc_socket_error("Socket write failed: {}".format(connection_error).encode()),
+            )
+
     cdef void write(self, grpc_slice_buffer * g_slice_buffer, grpc_custom_write_callback grpc_write_cb):
-        """Performs write to network socket in AsyncIO. 
-         
-        For each socket, Core guarantees there'll be only one ongoing write. 
-        When the write is finished, we need to call grpc_write_cb to notify 
-        Core that the work is done. 
-        """ 
-        assert not self._task_write 
+        """Performs write to network socket in AsyncIO.
+        
+        For each socket, Core guarantees there'll be only one ongoing write.
+        When the write is finished, we need to call grpc_write_cb to notify
+        Core that the work is done.
+        """
+        assert not self._task_write
         cdef char* start
-        cdef bytearray outbound_buffer = bytearray() 
+        cdef bytearray outbound_buffer = bytearray()
         for i in range(g_slice_buffer.count):
             start = grpc_slice_buffer_start(g_slice_buffer, i)
             length = grpc_slice_buffer_length(g_slice_buffer, i)
-            outbound_buffer.extend(<bytes>start[:length]) 
+            outbound_buffer.extend(<bytes>start[:length])
 
-        self._grpc_write_cb = grpc_write_cb 
-        self._task_write = self._loop.create_task(self._async_write(outbound_buffer)) 
+        self._grpc_write_cb = grpc_write_cb
+        self._task_write = self._loop.create_task(self._async_write(outbound_buffer))
 
     cdef bint is_connected(self):
         return self._reader and not self._reader._transport.is_closing()
 
     cdef void close(self):
-        if self._closed: 
-            return 
-        else: 
-            self._closed = True 
+        if self._closed:
+            return
+        else:
+            self._closed = True
         if self.is_connected():
             self._writer.close()
-        if self._task_listen and not self._task_listen.done(): 
-            self._task_listen.close() 
+        if self._task_listen and not self._task_listen.done():
+            self._task_listen.close()
         if self._server:
             self._server.close()
         # NOTE(lidiz) If the asyncio.Server is created from a Python socket,
@@ -179,15 +179,15 @@ cdef class _AsyncioSocket:
             self._py_socket.close()
 
     def _new_connection_callback(self, object reader, object writer):
-        # If the socket is closed, stop. 
-        if self._closed: 
-            return 
- 
-        # Close the connection if server is not started yet. 
-        if self._grpc_accept_cb == NULL: 
-            writer.close() 
-            return 
- 
+        # If the socket is closed, stop.
+        if self._closed:
+            return
+
+        # Close the connection if server is not started yet.
+        if self._grpc_accept_cb == NULL:
+            writer.close()
+            return
+
         client_socket = _AsyncioSocket.create(
             self._grpc_client_socket,
             reader,
@@ -197,20 +197,20 @@ cdef class _AsyncioSocket:
         self._grpc_client_socket.impl = <void*>client_socket
         cpython.Py_INCREF(client_socket)  # Py_DECREF in asyncio_socket_destroy
         # Accept callback expects to be called with:
-        # * grpc_custom_socket: A grpc custom socket for server 
-        # * grpc_custom_socket: A grpc custom socket for client (with new Socket instance) 
-        # * grpc_error: An error object 
+        # * grpc_custom_socket: A grpc custom socket for server
+        # * grpc_custom_socket: A grpc custom socket for client (with new Socket instance)
+        # * grpc_error: An error object
         self._grpc_accept_cb(self._grpc_socket, self._grpc_client_socket, grpc_error_none())
 
     cdef listen(self):
-        self._py_socket.listen(_ASYNCIO_STREAM_DEFAULT_SOCKET_BACKLOG) 
+        self._py_socket.listen(_ASYNCIO_STREAM_DEFAULT_SOCKET_BACKLOG)
         async def create_asyncio_server():
             self._server = await asyncio.start_server(
                 self._new_connection_callback,
                 sock=self._py_socket,
             )
 
-        self._task_listen = self._loop.create_task(create_asyncio_server()) 
+        self._task_listen = self._loop.create_task(create_asyncio_server())
 
     cdef accept(self,
                 grpc_custom_socket* grpc_socket_client,
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/timer.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/timer.pxd.pxi
index a9511dc5ad..76c3be0c57 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/timer.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/timer.pxd.pxi
@@ -15,11 +15,11 @@
 cdef class _AsyncioTimer:
     cdef:
         grpc_custom_timer * _grpc_timer
-        object _timer_future 
-        bint _active 
-        object _loop 
+        object _timer_future
+        bint _active
+        object _loop
 
     @staticmethod
-    cdef _AsyncioTimer create(grpc_custom_timer * grpc_timer, float timeout) 
+    cdef _AsyncioTimer create(grpc_custom_timer * grpc_timer, float timeout)
 
     cdef stop(self)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/timer.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/timer.pyx.pxi
index 7a6ffd1479..c1508373a4 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/timer.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/iomgr/timer.pyx.pxi
@@ -16,23 +16,23 @@
 cdef class _AsyncioTimer:
     def __cinit__(self):
         self._grpc_timer = NULL
-        self._timer_future = None 
-        self._active = False 
-        self._loop = get_working_loop() 
-        cpython.Py_INCREF(self) 
+        self._timer_future = None
+        self._active = False
+        self._loop = get_working_loop()
+        cpython.Py_INCREF(self)
 
     @staticmethod
-    cdef _AsyncioTimer create(grpc_custom_timer * grpc_timer, float timeout): 
+    cdef _AsyncioTimer create(grpc_custom_timer * grpc_timer, float timeout):
         timer = _AsyncioTimer()
         timer._grpc_timer = grpc_timer
-        timer._timer_future = timer._loop.call_later(timeout, timer.on_time_up) 
-        timer._active = True 
+        timer._timer_future = timer._loop.call_later(timeout, timer.on_time_up)
+        timer._active = True
         return timer
 
-    def on_time_up(self): 
-        self._active = False 
+    def on_time_up(self):
+        self._active = False
         grpc_custom_timer_callback(self._grpc_timer, <grpc_error*>0)
-        cpython.Py_DECREF(self) 
+        cpython.Py_DECREF(self)
 
     def __repr__(self):
         class_name = self.__class__.__name__ 
@@ -40,9 +40,9 @@ cdef class _AsyncioTimer:
         return f"<{class_name} {id_} deadline={self._deadline} active={self._active}>"
 
     cdef stop(self):
-        if not self._active: 
+        if not self._active:
             return
 
-        self._timer_future.cancel() 
-        self._active = False 
-        cpython.Py_DECREF(self) 
+        self._timer_future.cancel()
+        self._active = False
+        cpython.Py_DECREF(self)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_status.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_status.pxd.pxi
index c9fb962b6a..3780d8ddf2 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_status.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_status.pxd.pxi
@@ -1,29 +1,29 @@
-# Copyright 2019 gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Exceptions for the aio version of the RPC calls.""" 
- 
- 
-cdef class AioRpcStatus(Exception): 
-    cdef readonly: 
-        grpc_status_code _code 
-        str _details 
-        # Per the spec, only client-side status has trailing metadata. 
-        tuple _trailing_metadata 
-        str _debug_error_string 
- 
-    cpdef grpc_status_code code(self) 
-    cpdef str details(self) 
-    cpdef tuple trailing_metadata(self) 
-    cpdef str debug_error_string(self) 
-    cdef grpc_status_code c_code(self) 
+# Copyright 2019 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Exceptions for the aio version of the RPC calls."""
+
+
+cdef class AioRpcStatus(Exception):
+    cdef readonly:
+        grpc_status_code _code
+        str _details
+        # Per the spec, only client-side status has trailing metadata.
+        tuple _trailing_metadata
+        str _debug_error_string
+
+    cpdef grpc_status_code code(self)
+    cpdef str details(self)
+    cpdef tuple trailing_metadata(self)
+    cpdef str debug_error_string(self)
+    cdef grpc_status_code c_code(self)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_status.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_status.pyx.pxi
index 95890cfda3..07669fc157 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_status.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/rpc_status.pyx.pxi
@@ -1,44 +1,44 @@
-# Copyright 2019 gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Exceptions for the aio version of the RPC calls.""" 
- 
- 
-cdef class AioRpcStatus(Exception): 
- 
-    # The final status of gRPC is represented by three trailing metadata: 
-    # `grpc-status`, `grpc-status-message`, abd `grpc-status-details`. 
-    def __cinit__(self, 
-                  grpc_status_code code, 
-                  str details, 
-                  tuple trailing_metadata, 
-                  str debug_error_string): 
-        self._code = code 
-        self._details = details 
-        self._trailing_metadata = trailing_metadata 
-        self._debug_error_string = debug_error_string 
- 
-    cpdef grpc_status_code code(self): 
-        return self._code 
- 
-    cpdef str details(self): 
-        return self._details 
- 
-    cpdef tuple trailing_metadata(self): 
-        return self._trailing_metadata 
- 
-    cpdef str debug_error_string(self): 
-        return self._debug_error_string 
- 
-    cdef grpc_status_code c_code(self): 
-        return <grpc_status_code>self._code 
+# Copyright 2019 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Exceptions for the aio version of the RPC calls."""
+
+
+cdef class AioRpcStatus(Exception):
+
+    # The final status of gRPC is represented by three trailing metadata:
+    # `grpc-status`, `grpc-status-message`, abd `grpc-status-details`.
+    def __cinit__(self,
+                  grpc_status_code code,
+                  str details,
+                  tuple trailing_metadata,
+                  str debug_error_string):
+        self._code = code
+        self._details = details
+        self._trailing_metadata = trailing_metadata
+        self._debug_error_string = debug_error_string
+
+    cpdef grpc_status_code code(self):
+        return self._code
+
+    cpdef str details(self):
+        return self._details
+
+    cpdef tuple trailing_metadata(self):
+        return self._trailing_metadata
+
+    cpdef str debug_error_string(self):
+        return self._debug_error_string
+
+    cdef grpc_status_code c_code(self):
+        return <grpc_status_code>self._code
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pxd.pxi
index 5cca5b044c..46a47bd1ba 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pxd.pxi
@@ -20,45 +20,45 @@ cdef class _HandlerCallDetails:
 cdef class RPCState(GrpcCallWrapper):
     cdef grpc_call_details details
     cdef grpc_metadata_array request_metadata
-    cdef AioServer server 
-    # NOTE(lidiz) Under certain corner case, receiving the client close 
-    # operation won't immediately fail ongoing RECV_MESSAGE operations. Here I 
-    # added a flag to workaround this unexpected behavior. 
-    cdef bint client_closed 
-    cdef object abort_exception 
-    cdef bint metadata_sent 
-    cdef bint status_sent 
-    cdef grpc_status_code status_code 
-    cdef str status_details 
-    cdef tuple trailing_metadata 
-    cdef object compression_algorithm 
-    cdef bint disable_next_compression 
+    cdef AioServer server
+    # NOTE(lidiz) Under certain corner case, receiving the client close
+    # operation won't immediately fail ongoing RECV_MESSAGE operations. Here I
+    # added a flag to workaround this unexpected behavior.
+    cdef bint client_closed
+    cdef object abort_exception
+    cdef bint metadata_sent
+    cdef bint status_sent
+    cdef grpc_status_code status_code
+    cdef str status_details
+    cdef tuple trailing_metadata
+    cdef object compression_algorithm
+    cdef bint disable_next_compression
 
     cdef bytes method(self)
-    cdef tuple invocation_metadata(self) 
-    cdef void raise_for_termination(self) except * 
-    cdef int get_write_flag(self) 
-    cdef Operation create_send_initial_metadata_op_if_not_sent(self) 
+    cdef tuple invocation_metadata(self)
+    cdef void raise_for_termination(self) except *
+    cdef int get_write_flag(self)
+    cdef Operation create_send_initial_metadata_op_if_not_sent(self)
+
+
+cdef class _ServicerContext:
+    cdef RPCState _rpc_state
+    cdef object _loop  # asyncio.AbstractEventLoop
+    cdef object _request_deserializer  # Callable[[bytes], Any]
+    cdef object _response_serializer  # Callable[[Any], bytes]
+
+
+cdef class _SyncServicerContext:
+    cdef _ServicerContext _context
+    cdef list _callbacks
+    cdef object _loop  # asyncio.AbstractEventLoop
+
+
+cdef class _MessageReceiver:
+    cdef _ServicerContext _servicer_context
+    cdef object _agen
 
 
-cdef class _ServicerContext: 
-    cdef RPCState _rpc_state 
-    cdef object _loop  # asyncio.AbstractEventLoop 
-    cdef object _request_deserializer  # Callable[[bytes], Any] 
-    cdef object _response_serializer  # Callable[[Any], bytes] 
- 
- 
-cdef class _SyncServicerContext: 
-    cdef _ServicerContext _context 
-    cdef list _callbacks 
-    cdef object _loop  # asyncio.AbstractEventLoop 
- 
- 
-cdef class _MessageReceiver: 
-    cdef _ServicerContext _servicer_context 
-    cdef object _agen 
- 
- 
 cdef enum AioServerStatus:
     AIO_SERVER_STATUS_UNKNOWN
     AIO_SERVER_STATUS_READY
@@ -77,7 +77,7 @@ cdef class AioServer:
     cdef object _shutdown_completed  # asyncio.Future
     cdef CallbackWrapper _shutdown_callback_wrapper
     cdef object _crash_exception  # Exception
-    cdef tuple _interceptors 
-    cdef object _thread_pool  # concurrent.futures.ThreadPoolExecutor 
- 
-    cdef thread_pool(self) 
+    cdef tuple _interceptors
+    cdef object _thread_pool  # concurrent.futures.ThreadPoolExecutor
+
+    cdef thread_pool(self)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pyx.pxi
index 5573be7671..a630ed8811 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/aio/server.pyx.pxi
@@ -12,786 +12,786 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
- 
-import inspect 
-import traceback 
-import functools 
- 
- 
+
+import inspect
+import traceback
+import functools
+
+
 cdef int _EMPTY_FLAG = 0
-cdef str _RPC_FINISHED_DETAILS = 'RPC already finished.' 
-cdef str _SERVER_STOPPED_DETAILS = 'Server already stopped.' 
-
-cdef _augment_metadata(tuple metadata, object compression): 
-    if compression is None: 
-        return metadata 
-    else: 
-        return (( 
-            GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY, 
-            _COMPRESSION_METADATA_STRING_MAPPING[compression] 
-        ),) + metadata 
- 
- 
+cdef str _RPC_FINISHED_DETAILS = 'RPC already finished.'
+cdef str _SERVER_STOPPED_DETAILS = 'Server already stopped.'
+
+cdef _augment_metadata(tuple metadata, object compression):
+    if compression is None:
+        return metadata
+    else:
+        return ((
+            GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY,
+            _COMPRESSION_METADATA_STRING_MAPPING[compression]
+        ),) + metadata
+
+
 cdef class _HandlerCallDetails:
     def __cinit__(self, str method, tuple invocation_metadata):
         self.method = method
         self.invocation_metadata = invocation_metadata
 
 
-class _ServerStoppedError(BaseError): 
-    """Raised if the server is stopped.""" 
- 
- 
+class _ServerStoppedError(BaseError):
+    """Raised if the server is stopped."""
+
+
 cdef class RPCState:
 
-    def __cinit__(self, AioServer server): 
-        init_grpc_aio() 
-        self.call = NULL 
-        self.server = server 
+    def __cinit__(self, AioServer server):
+        init_grpc_aio()
+        self.call = NULL
+        self.server = server
         grpc_metadata_array_init(&self.request_metadata)
         grpc_call_details_init(&self.details)
-        self.client_closed = False 
-        self.abort_exception = None 
-        self.metadata_sent = False 
-        self.status_sent = False 
-        self.status_code = StatusCode.ok 
-        self.status_details = '' 
-        self.trailing_metadata = _IMMUTABLE_EMPTY_METADATA 
-        self.compression_algorithm = None 
-        self.disable_next_compression = False 
+        self.client_closed = False
+        self.abort_exception = None
+        self.metadata_sent = False
+        self.status_sent = False
+        self.status_code = StatusCode.ok
+        self.status_details = ''
+        self.trailing_metadata = _IMMUTABLE_EMPTY_METADATA
+        self.compression_algorithm = None
+        self.disable_next_compression = False
 
     cdef bytes method(self):
-        return _slice_bytes(self.details.method) 
-
-    cdef tuple invocation_metadata(self): 
-        return _metadata(&self.request_metadata) 
- 
-    cdef void raise_for_termination(self) except *: 
-        """Raise exceptions if RPC is not running. 
- 
-        Server method handlers may suppress the abort exception. We need to halt 
-        the RPC execution in that case. This function needs to be called after 
-        running application code. 
- 
-        Also, the server may stop unexpected. We need to check before calling 
-        into Core functions, otherwise, segfault. 
-        """ 
-        if self.abort_exception is not None: 
-            raise self.abort_exception 
-        if self.status_sent: 
-            raise UsageError(_RPC_FINISHED_DETAILS) 
-        if self.server._status == AIO_SERVER_STATUS_STOPPED: 
-            raise _ServerStoppedError(_SERVER_STOPPED_DETAILS) 
- 
-    cdef int get_write_flag(self): 
-        if self.disable_next_compression: 
-            self.disable_next_compression = False 
-            return WriteFlag.no_compress 
-        else: 
-            return _EMPTY_FLAG 
- 
-    cdef Operation create_send_initial_metadata_op_if_not_sent(self): 
-        cdef SendInitialMetadataOperation op 
-        if self.metadata_sent: 
-            return None 
-        else: 
-            op = SendInitialMetadataOperation( 
-                _augment_metadata(_IMMUTABLE_EMPTY_METADATA, self.compression_algorithm), 
-                _EMPTY_FLAG 
-            ) 
-            return op 
- 
+        return _slice_bytes(self.details.method)
+
+    cdef tuple invocation_metadata(self):
+        return _metadata(&self.request_metadata)
+
+    cdef void raise_for_termination(self) except *:
+        """Raise exceptions if RPC is not running.
+
+        Server method handlers may suppress the abort exception. We need to halt
+        the RPC execution in that case. This function needs to be called after
+        running application code.
+
+        Also, the server may stop unexpected. We need to check before calling
+        into Core functions, otherwise, segfault.
+        """
+        if self.abort_exception is not None:
+            raise self.abort_exception
+        if self.status_sent:
+            raise UsageError(_RPC_FINISHED_DETAILS)
+        if self.server._status == AIO_SERVER_STATUS_STOPPED:
+            raise _ServerStoppedError(_SERVER_STOPPED_DETAILS)
+
+    cdef int get_write_flag(self):
+        if self.disable_next_compression:
+            self.disable_next_compression = False
+            return WriteFlag.no_compress
+        else:
+            return _EMPTY_FLAG
+
+    cdef Operation create_send_initial_metadata_op_if_not_sent(self):
+        cdef SendInitialMetadataOperation op
+        if self.metadata_sent:
+            return None
+        else:
+            op = SendInitialMetadataOperation(
+                _augment_metadata(_IMMUTABLE_EMPTY_METADATA, self.compression_algorithm),
+                _EMPTY_FLAG
+            )
+            return op
+
     def __dealloc__(self):
         """Cleans the Core objects."""
         grpc_call_details_destroy(&self.details)
         grpc_metadata_array_destroy(&self.request_metadata)
         if self.call:
             grpc_call_unref(self.call)
-        shutdown_grpc_aio() 
-
-
-cdef class _ServicerContext: 
- 
-    def __cinit__(self, 
-                  RPCState rpc_state, 
-                  object request_deserializer, 
-                  object response_serializer, 
-                  object loop): 
-        self._rpc_state = rpc_state 
-        self._request_deserializer = request_deserializer 
-        self._response_serializer = response_serializer 
-        self._loop = loop 
- 
-    async def read(self): 
-        cdef bytes raw_message 
-        self._rpc_state.raise_for_termination() 
- 
-        raw_message = await _receive_message(self._rpc_state, self._loop) 
-        self._rpc_state.raise_for_termination() 
- 
-        if raw_message is None: 
-            return EOF 
-        else: 
-            return deserialize(self._request_deserializer, 
-                            raw_message) 
- 
-    async def write(self, object message): 
-        self._rpc_state.raise_for_termination() 
- 
-        await _send_message(self._rpc_state, 
-                            serialize(self._response_serializer, message), 
-                            self._rpc_state.create_send_initial_metadata_op_if_not_sent(), 
-                            self._rpc_state.get_write_flag(), 
-                            self._loop) 
-        self._rpc_state.metadata_sent = True 
- 
-    async def send_initial_metadata(self, object metadata): 
-        self._rpc_state.raise_for_termination() 
- 
-        if self._rpc_state.metadata_sent: 
-            raise UsageError('Send initial metadata failed: already sent') 
-        else: 
-            await _send_initial_metadata( 
-                self._rpc_state, 
-                _augment_metadata(tuple(metadata), self._rpc_state.compression_algorithm), 
-                _EMPTY_FLAG, 
-                self._loop 
-            ) 
-            self._rpc_state.metadata_sent = True 
- 
-    async def abort(self, 
-              object code, 
-              str details='', 
-              tuple trailing_metadata=_IMMUTABLE_EMPTY_METADATA): 
-        if self._rpc_state.abort_exception is not None: 
-            raise UsageError('Abort already called!') 
-        else: 
-            # Keeps track of the exception object. After abort happen, the RPC 
-            # should stop execution. However, if users decided to suppress it, it 
-            # could lead to undefined behavior. 
-            self._rpc_state.abort_exception = AbortError('Locally aborted.') 
- 
-            if trailing_metadata == _IMMUTABLE_EMPTY_METADATA and self._rpc_state.trailing_metadata: 
-                trailing_metadata = self._rpc_state.trailing_metadata 
- 
-            if details == '' and self._rpc_state.status_details: 
-                details = self._rpc_state.status_details 
- 
-            actual_code = get_status_code(code) 
- 
-            self._rpc_state.status_sent = True 
-            await _send_error_status_from_server( 
-                self._rpc_state, 
-                actual_code, 
-                details, 
-                trailing_metadata, 
-                self._rpc_state.create_send_initial_metadata_op_if_not_sent(), 
-                self._loop 
-            ) 
- 
-            raise self._rpc_state.abort_exception 
- 
-    async def abort_with_status(self, object status): 
-        await self.abort(status.code, status.details, status.trailing_metadata) 
- 
-    def set_trailing_metadata(self, object metadata): 
-        self._rpc_state.trailing_metadata = tuple(metadata) 
- 
-    def invocation_metadata(self): 
-        return self._rpc_state.invocation_metadata() 
- 
-    def set_code(self, object code): 
-        self._rpc_state.status_code = get_status_code(code) 
- 
-    def set_details(self, str details): 
-        self._rpc_state.status_details = details 
- 
-    def set_compression(self, object compression): 
-        if self._rpc_state.metadata_sent: 
-            raise RuntimeError('Compression setting must be specified before sending initial metadata') 
-        else: 
-            self._rpc_state.compression_algorithm = compression 
- 
-    def disable_next_message_compression(self): 
-        self._rpc_state.disable_next_compression = True 
- 
-    def peer(self): 
-        cdef char *c_peer = NULL 
-        c_peer = grpc_call_get_peer(self._rpc_state.call) 
-        peer = (<bytes>c_peer).decode('utf8') 
-        gpr_free(c_peer) 
-        return peer 
- 
-    def peer_identities(self): 
-        cdef Call query_call = Call() 
-        query_call.c_call = self._rpc_state.call 
-        identities = peer_identities(query_call) 
-        query_call.c_call = NULL 
-        return identities 
- 
-    def peer_identity_key(self): 
-        cdef Call query_call = Call() 
-        query_call.c_call = self._rpc_state.call 
-        identity_key = peer_identity_key(query_call) 
-        query_call.c_call = NULL 
-        if identity_key: 
-            return identity_key.decode('utf8') 
-        else: 
-            return None 
- 
-    def auth_context(self): 
-        cdef Call query_call = Call() 
-        query_call.c_call = self._rpc_state.call 
-        bytes_ctx = auth_context(query_call) 
-        query_call.c_call = NULL 
-        if bytes_ctx: 
-            ctx = {} 
-            for key in bytes_ctx: 
-                ctx[key.decode('utf8')] = bytes_ctx[key] 
-            return ctx 
-        else: 
-            return {} 
- 
- 
-cdef class _SyncServicerContext: 
-    """Sync servicer context for sync handler compatibility.""" 
- 
-    def __cinit__(self, 
-                  _ServicerContext context): 
-        self._context = context 
-        self._callbacks = [] 
-        self._loop = context._loop 
- 
-    def abort(self, 
-              object code, 
-              str details='', 
-              tuple trailing_metadata=_IMMUTABLE_EMPTY_METADATA): 
-        future = asyncio.run_coroutine_threadsafe( 
-            self._context.abort(code, details, trailing_metadata), 
-            self._loop) 
-        # Abort should raise an AbortError 
-        future.exception() 
- 
-    def send_initial_metadata(self, object metadata): 
-        future = asyncio.run_coroutine_threadsafe( 
-            self._context.send_initial_metadata(metadata), 
-            self._loop) 
-        future.result() 
- 
-    def set_trailing_metadata(self, object metadata): 
-        self._context.set_trailing_metadata(metadata) 
- 
-    def invocation_metadata(self): 
-        return self._context.invocation_metadata() 
- 
-    def set_code(self, object code): 
-        self._context.set_code(code) 
- 
-    def set_details(self, str details): 
-        self._context.set_details(details) 
- 
-    def set_compression(self, object compression): 
-        self._context.set_compression(compression) 
- 
-    def disable_next_message_compression(self): 
-        self._context.disable_next_message_compression() 
- 
-    def add_callback(self, object callback): 
-        self._callbacks.append(callback) 
- 
-    def peer(self): 
-        return self._context.peer() 
- 
-    def peer_identities(self): 
-        return self._context.peer_identities() 
- 
-    def peer_identity_key(self): 
-        return self._context.peer_identity_key() 
- 
-    def auth_context(self): 
-        return self._context.auth_context() 
- 
- 
-async def _run_interceptor(object interceptors, object query_handler, 
-                           object handler_call_details): 
-    interceptor = next(interceptors, None) 
-    if interceptor: 
-        continuation = functools.partial(_run_interceptor, interceptors, 
-                                         query_handler) 
-        return await interceptor.intercept_service(continuation, handler_call_details) 
-    else: 
-        return query_handler(handler_call_details) 
- 
- 
-def _is_async_handler(object handler): 
-    """Inspect if a method handler is async or sync.""" 
-    return inspect.isawaitable(handler) or inspect.iscoroutinefunction(handler) or inspect.isasyncgenfunction(handler) 
- 
- 
-async def _find_method_handler(str method, tuple metadata, list generic_handlers, 
-                          tuple interceptors): 
-    def query_handlers(handler_call_details): 
-        for generic_handler in generic_handlers: 
-            method_handler = generic_handler.service(handler_call_details) 
-            if method_handler is not None: 
-                return method_handler 
-        return None 
- 
-    cdef _HandlerCallDetails handler_call_details = _HandlerCallDetails(method, 
-                                                                        metadata) 
-    # interceptor 
-    if interceptors: 
-        return await _run_interceptor(iter(interceptors), query_handlers, 
-                                      handler_call_details) 
-    else: 
-        return query_handlers(handler_call_details) 
- 
-
-async def _finish_handler_with_unary_response(RPCState rpc_state, 
-                                              object unary_handler, 
-                                              object request, 
-                                              _ServicerContext servicer_context, 
-                                              object response_serializer, 
-                                              object loop): 
-    """Finishes server method handler with a single response. 
- 
-    This function executes the application handler, and handles response 
-    sending, as well as errors. It is shared between unary-unary and 
-    stream-unary handlers. 
-    """ 
-    # Executes application logic 
-    cdef object response_message 
-    cdef _SyncServicerContext sync_servicer_context 
- 
-    if _is_async_handler(unary_handler): 
-        # Run async method handlers in this coroutine 
-        response_message = await unary_handler( 
-            request, 
-            servicer_context, 
-        ) 
-    else: 
-        # Run sync method handlers in the thread pool 
-        sync_servicer_context = _SyncServicerContext(servicer_context) 
-        response_message = await loop.run_in_executor( 
-            rpc_state.server.thread_pool(), 
-            unary_handler, 
-            request, 
-            sync_servicer_context, 
-        ) 
-        # Support sync-stack callback 
-        for callback in sync_servicer_context._callbacks: 
-            callback() 
- 
-    # Raises exception if aborted 
-    rpc_state.raise_for_termination() 
- 
-    # Serializes the response message 
-    cdef bytes response_raw 
-    if rpc_state.status_code == StatusCode.ok: 
-        response_raw = serialize( 
-            response_serializer, 
-            response_message, 
-        ) 
-    else: 
-        # Discards the response message if the status code is non-OK. 
-        response_raw = b'' 
- 
-    # Assembles the batch operations 
-    cdef tuple finish_ops 
-    finish_ops = ( 
-        SendMessageOperation(response_raw, rpc_state.get_write_flag()), 
-        SendStatusFromServerOperation( 
-            rpc_state.trailing_metadata, 
-            rpc_state.status_code, 
-            rpc_state.status_details, 
-            _EMPTY_FLAGS, 
-        ), 
-    ) 
-    if not rpc_state.metadata_sent: 
-        finish_ops = prepend_send_initial_metadata_op( 
-            finish_ops, 
-            None) 
-    rpc_state.metadata_sent = True 
-    rpc_state.status_sent = True 
-    await execute_batch(rpc_state, finish_ops, loop) 
- 
- 
-async def _finish_handler_with_stream_responses(RPCState rpc_state, 
-                                                object stream_handler, 
-                                                object request, 
-                                                _ServicerContext servicer_context, 
-                                                object loop): 
-    """Finishes server method handler with multiple responses. 
- 
-    This function executes the application handler, and handles response 
-    sending, as well as errors. It is shared between unary-stream and 
-    stream-stream handlers. 
-    """ 
-    cdef object async_response_generator 
-    cdef object response_message 
- 
-    if inspect.iscoroutinefunction(stream_handler): 
-        # Case 1: Coroutine async handler - using reader-writer API 
-        # The handler uses reader / writer API, returns None. 
-        await stream_handler( 
-            request, 
-            servicer_context, 
-        ) 
-    else: 
-        if inspect.isasyncgenfunction(stream_handler): 
-            # Case 2: Async handler - async generator 
-            # The handler uses async generator API 
-            async_response_generator = stream_handler( 
-                request, 
-                servicer_context, 
-            ) 
-        else: 
-            # Case 3: Sync handler - normal generator 
-            # NOTE(lidiz) Streaming handler in sync stack is either a generator 
-            # function or a function returns a generator. 
-            sync_servicer_context = _SyncServicerContext(servicer_context) 
-            gen = stream_handler(request, sync_servicer_context) 
-            async_response_generator = generator_to_async_generator(gen, 
-                                                                    loop, 
-                                                                    rpc_state.server.thread_pool()) 
- 
-        # Consumes messages from the generator 
-        async for response_message in async_response_generator: 
-            # Raises exception if aborted 
-            rpc_state.raise_for_termination() 
- 
-            await servicer_context.write(response_message) 
- 
-    # Raises exception if aborted 
-    rpc_state.raise_for_termination() 
- 
-    # Sends the final status of this RPC 
-    cdef SendStatusFromServerOperation op = SendStatusFromServerOperation( 
-        rpc_state.trailing_metadata, 
-        rpc_state.status_code, 
-        rpc_state.status_details, 
-        _EMPTY_FLAGS, 
-    ) 
- 
-    cdef tuple finish_ops = (op,) 
-    if not rpc_state.metadata_sent: 
-        finish_ops = prepend_send_initial_metadata_op( 
-            finish_ops, 
-            None 
-        ) 
-    rpc_state.metadata_sent = True 
-    rpc_state.status_sent = True 
-    await execute_batch(rpc_state, finish_ops, loop) 
- 
- 
+        shutdown_grpc_aio()
+
+
+cdef class _ServicerContext:
+
+    def __cinit__(self,
+                  RPCState rpc_state,
+                  object request_deserializer,
+                  object response_serializer,
+                  object loop):
+        self._rpc_state = rpc_state
+        self._request_deserializer = request_deserializer
+        self._response_serializer = response_serializer
+        self._loop = loop
+
+    async def read(self):
+        cdef bytes raw_message
+        self._rpc_state.raise_for_termination()
+
+        raw_message = await _receive_message(self._rpc_state, self._loop)
+        self._rpc_state.raise_for_termination()
+
+        if raw_message is None:
+            return EOF
+        else:
+            return deserialize(self._request_deserializer,
+                            raw_message)
+
+    async def write(self, object message):
+        self._rpc_state.raise_for_termination()
+
+        await _send_message(self._rpc_state,
+                            serialize(self._response_serializer, message),
+                            self._rpc_state.create_send_initial_metadata_op_if_not_sent(),
+                            self._rpc_state.get_write_flag(),
+                            self._loop)
+        self._rpc_state.metadata_sent = True
+
+    async def send_initial_metadata(self, object metadata):
+        self._rpc_state.raise_for_termination()
+
+        if self._rpc_state.metadata_sent:
+            raise UsageError('Send initial metadata failed: already sent')
+        else:
+            await _send_initial_metadata(
+                self._rpc_state,
+                _augment_metadata(tuple(metadata), self._rpc_state.compression_algorithm),
+                _EMPTY_FLAG,
+                self._loop
+            )
+            self._rpc_state.metadata_sent = True
+
+    async def abort(self,
+              object code,
+              str details='',
+              tuple trailing_metadata=_IMMUTABLE_EMPTY_METADATA):
+        if self._rpc_state.abort_exception is not None:
+            raise UsageError('Abort already called!')
+        else:
+            # Keeps track of the exception object. After abort happen, the RPC
+            # should stop execution. However, if users decided to suppress it, it
+            # could lead to undefined behavior.
+            self._rpc_state.abort_exception = AbortError('Locally aborted.')
+
+            if trailing_metadata == _IMMUTABLE_EMPTY_METADATA and self._rpc_state.trailing_metadata:
+                trailing_metadata = self._rpc_state.trailing_metadata
+
+            if details == '' and self._rpc_state.status_details:
+                details = self._rpc_state.status_details
+
+            actual_code = get_status_code(code)
+
+            self._rpc_state.status_sent = True
+            await _send_error_status_from_server(
+                self._rpc_state,
+                actual_code,
+                details,
+                trailing_metadata,
+                self._rpc_state.create_send_initial_metadata_op_if_not_sent(),
+                self._loop
+            )
+
+            raise self._rpc_state.abort_exception
+
+    async def abort_with_status(self, object status):
+        await self.abort(status.code, status.details, status.trailing_metadata)
+
+    def set_trailing_metadata(self, object metadata):
+        self._rpc_state.trailing_metadata = tuple(metadata)
+
+    def invocation_metadata(self):
+        return self._rpc_state.invocation_metadata()
+
+    def set_code(self, object code):
+        self._rpc_state.status_code = get_status_code(code)
+
+    def set_details(self, str details):
+        self._rpc_state.status_details = details
+
+    def set_compression(self, object compression):
+        if self._rpc_state.metadata_sent:
+            raise RuntimeError('Compression setting must be specified before sending initial metadata')
+        else:
+            self._rpc_state.compression_algorithm = compression
+
+    def disable_next_message_compression(self):
+        self._rpc_state.disable_next_compression = True
+
+    def peer(self):
+        cdef char *c_peer = NULL
+        c_peer = grpc_call_get_peer(self._rpc_state.call)
+        peer = (<bytes>c_peer).decode('utf8')
+        gpr_free(c_peer)
+        return peer
+
+    def peer_identities(self):
+        cdef Call query_call = Call()
+        query_call.c_call = self._rpc_state.call
+        identities = peer_identities(query_call)
+        query_call.c_call = NULL
+        return identities
+
+    def peer_identity_key(self):
+        cdef Call query_call = Call()
+        query_call.c_call = self._rpc_state.call
+        identity_key = peer_identity_key(query_call)
+        query_call.c_call = NULL
+        if identity_key:
+            return identity_key.decode('utf8')
+        else:
+            return None
+
+    def auth_context(self):
+        cdef Call query_call = Call()
+        query_call.c_call = self._rpc_state.call
+        bytes_ctx = auth_context(query_call)
+        query_call.c_call = NULL
+        if bytes_ctx:
+            ctx = {}
+            for key in bytes_ctx:
+                ctx[key.decode('utf8')] = bytes_ctx[key]
+            return ctx
+        else:
+            return {}
+
+
+cdef class _SyncServicerContext:
+    """Sync servicer context for sync handler compatibility."""
+
+    def __cinit__(self,
+                  _ServicerContext context):
+        self._context = context
+        self._callbacks = []
+        self._loop = context._loop
+
+    def abort(self,
+              object code,
+              str details='',
+              tuple trailing_metadata=_IMMUTABLE_EMPTY_METADATA):
+        future = asyncio.run_coroutine_threadsafe(
+            self._context.abort(code, details, trailing_metadata),
+            self._loop)
+        # Abort should raise an AbortError
+        future.exception()
+
+    def send_initial_metadata(self, object metadata):
+        future = asyncio.run_coroutine_threadsafe(
+            self._context.send_initial_metadata(metadata),
+            self._loop)
+        future.result()
+
+    def set_trailing_metadata(self, object metadata):
+        self._context.set_trailing_metadata(metadata)
+
+    def invocation_metadata(self):
+        return self._context.invocation_metadata()
+
+    def set_code(self, object code):
+        self._context.set_code(code)
+
+    def set_details(self, str details):
+        self._context.set_details(details)
+
+    def set_compression(self, object compression):
+        self._context.set_compression(compression)
+
+    def disable_next_message_compression(self):
+        self._context.disable_next_message_compression()
+
+    def add_callback(self, object callback):
+        self._callbacks.append(callback)
+
+    def peer(self):
+        return self._context.peer()
+
+    def peer_identities(self):
+        return self._context.peer_identities()
+
+    def peer_identity_key(self):
+        return self._context.peer_identity_key()
+
+    def auth_context(self):
+        return self._context.auth_context()
+
+
+async def _run_interceptor(object interceptors, object query_handler,
+                           object handler_call_details):
+    interceptor = next(interceptors, None)
+    if interceptor:
+        continuation = functools.partial(_run_interceptor, interceptors,
+                                         query_handler)
+        return await interceptor.intercept_service(continuation, handler_call_details)
+    else:
+        return query_handler(handler_call_details)
+
+
+def _is_async_handler(object handler):
+    """Inspect if a method handler is async or sync."""
+    return inspect.isawaitable(handler) or inspect.iscoroutinefunction(handler) or inspect.isasyncgenfunction(handler)
+
+
+async def _find_method_handler(str method, tuple metadata, list generic_handlers,
+                          tuple interceptors):
+    def query_handlers(handler_call_details):
+        for generic_handler in generic_handlers:
+            method_handler = generic_handler.service(handler_call_details)
+            if method_handler is not None:
+                return method_handler
+        return None
+
+    cdef _HandlerCallDetails handler_call_details = _HandlerCallDetails(method,
+                                                                        metadata)
+    # interceptor
+    if interceptors:
+        return await _run_interceptor(iter(interceptors), query_handlers,
+                                      handler_call_details)
+    else:
+        return query_handlers(handler_call_details)
+
+
+async def _finish_handler_with_unary_response(RPCState rpc_state,
+                                              object unary_handler,
+                                              object request,
+                                              _ServicerContext servicer_context,
+                                              object response_serializer,
+                                              object loop):
+    """Finishes server method handler with a single response.
+
+    This function executes the application handler, and handles response
+    sending, as well as errors. It is shared between unary-unary and
+    stream-unary handlers.
+    """
+    # Executes application logic
+    cdef object response_message
+    cdef _SyncServicerContext sync_servicer_context
+
+    if _is_async_handler(unary_handler):
+        # Run async method handlers in this coroutine
+        response_message = await unary_handler(
+            request,
+            servicer_context,
+        )
+    else:
+        # Run sync method handlers in the thread pool
+        sync_servicer_context = _SyncServicerContext(servicer_context)
+        response_message = await loop.run_in_executor(
+            rpc_state.server.thread_pool(),
+            unary_handler,
+            request,
+            sync_servicer_context,
+        )
+        # Support sync-stack callback
+        for callback in sync_servicer_context._callbacks:
+            callback()
+
+    # Raises exception if aborted
+    rpc_state.raise_for_termination()
+
+    # Serializes the response message
+    cdef bytes response_raw
+    if rpc_state.status_code == StatusCode.ok:
+        response_raw = serialize(
+            response_serializer,
+            response_message,
+        )
+    else:
+        # Discards the response message if the status code is non-OK.
+        response_raw = b''
+
+    # Assembles the batch operations
+    cdef tuple finish_ops
+    finish_ops = (
+        SendMessageOperation(response_raw, rpc_state.get_write_flag()),
+        SendStatusFromServerOperation(
+            rpc_state.trailing_metadata,
+            rpc_state.status_code,
+            rpc_state.status_details,
+            _EMPTY_FLAGS,
+        ),
+    )
+    if not rpc_state.metadata_sent:
+        finish_ops = prepend_send_initial_metadata_op(
+            finish_ops,
+            None)
+    rpc_state.metadata_sent = True
+    rpc_state.status_sent = True
+    await execute_batch(rpc_state, finish_ops, loop)
+
+
+async def _finish_handler_with_stream_responses(RPCState rpc_state,
+                                                object stream_handler,
+                                                object request,
+                                                _ServicerContext servicer_context,
+                                                object loop):
+    """Finishes server method handler with multiple responses.
+
+    This function executes the application handler, and handles response
+    sending, as well as errors. It is shared between unary-stream and
+    stream-stream handlers.
+    """
+    cdef object async_response_generator
+    cdef object response_message
+
+    if inspect.iscoroutinefunction(stream_handler):
+        # Case 1: Coroutine async handler - using reader-writer API
+        # The handler uses reader / writer API, returns None.
+        await stream_handler(
+            request,
+            servicer_context,
+        )
+    else:
+        if inspect.isasyncgenfunction(stream_handler):
+            # Case 2: Async handler - async generator
+            # The handler uses async generator API
+            async_response_generator = stream_handler(
+                request,
+                servicer_context,
+            )
+        else:
+            # Case 3: Sync handler - normal generator
+            # NOTE(lidiz) Streaming handler in sync stack is either a generator
+            # function or a function returns a generator.
+            sync_servicer_context = _SyncServicerContext(servicer_context)
+            gen = stream_handler(request, sync_servicer_context)
+            async_response_generator = generator_to_async_generator(gen,
+                                                                    loop,
+                                                                    rpc_state.server.thread_pool())
+
+        # Consumes messages from the generator
+        async for response_message in async_response_generator:
+            # Raises exception if aborted
+            rpc_state.raise_for_termination()
+
+            await servicer_context.write(response_message)
+
+    # Raises exception if aborted
+    rpc_state.raise_for_termination()
+
+    # Sends the final status of this RPC
+    cdef SendStatusFromServerOperation op = SendStatusFromServerOperation(
+        rpc_state.trailing_metadata,
+        rpc_state.status_code,
+        rpc_state.status_details,
+        _EMPTY_FLAGS,
+    )
+
+    cdef tuple finish_ops = (op,)
+    if not rpc_state.metadata_sent:
+        finish_ops = prepend_send_initial_metadata_op(
+            finish_ops,
+            None
+        )
+    rpc_state.metadata_sent = True
+    rpc_state.status_sent = True
+    await execute_batch(rpc_state, finish_ops, loop)
+
+
 async def _handle_unary_unary_rpc(object method_handler,
                                   RPCState rpc_state,
                                   object loop):
     # Receives request message
-    cdef bytes request_raw = await _receive_message(rpc_state, loop) 
-    if request_raw is None: 
-        # The RPC was cancelled immediately after start on client side. 
-        return 
+    cdef bytes request_raw = await _receive_message(rpc_state, loop)
+    if request_raw is None:
+        # The RPC was cancelled immediately after start on client side.
+        return
+
+    # Deserializes the request message
+    cdef object request_message = deserialize(
+        method_handler.request_deserializer,
+        request_raw,
+    )
+
+    # Creates a dedecated ServicerContext
+    cdef _ServicerContext servicer_context = _ServicerContext(
+        rpc_state,
+        None,
+        None,
+        loop,
+    )
+
+    # Finishes the application handler
+    await _finish_handler_with_unary_response(
+        rpc_state,
+        method_handler.unary_unary,
+        request_message,
+        servicer_context,
+        method_handler.response_serializer,
+        loop
+    )
+
+
+async def _handle_unary_stream_rpc(object method_handler,
+                                   RPCState rpc_state,
+                                   object loop):
+    # Receives request message
+    cdef bytes request_raw = await _receive_message(rpc_state, loop)
+    if request_raw is None:
+        return
 
     # Deserializes the request message
-    cdef object request_message = deserialize( 
-        method_handler.request_deserializer, 
-        request_raw, 
-    ) 
-
-    # Creates a dedecated ServicerContext 
-    cdef _ServicerContext servicer_context = _ServicerContext( 
-        rpc_state, 
-        None, 
-        None, 
-        loop, 
-    ) 
-
-    # Finishes the application handler 
-    await _finish_handler_with_unary_response( 
-        rpc_state, 
-        method_handler.unary_unary, 
-        request_message, 
-        servicer_context, 
-        method_handler.response_serializer, 
-        loop 
-    ) 
-
- 
-async def _handle_unary_stream_rpc(object method_handler, 
-                                   RPCState rpc_state, 
-                                   object loop): 
-    # Receives request message 
-    cdef bytes request_raw = await _receive_message(rpc_state, loop) 
-    if request_raw is None: 
-        return 
- 
-    # Deserializes the request message 
-    cdef object request_message = deserialize( 
-        method_handler.request_deserializer, 
-        request_raw, 
+    cdef object request_message = deserialize(
+        method_handler.request_deserializer,
+        request_raw,
+    )
+
+    # Creates a dedecated ServicerContext
+    cdef _ServicerContext servicer_context = _ServicerContext(
+        rpc_state,
+        method_handler.request_deserializer,
+        method_handler.response_serializer,
+        loop,
+    )
+
+    # Finishes the application handler
+    await _finish_handler_with_stream_responses(
+        rpc_state,
+        method_handler.unary_stream,
+        request_message,
+        servicer_context,
+        loop,
+    )
+
+
+cdef class _MessageReceiver:
+    """Bridge between the async generator API and the reader-writer API."""
+
+    def __cinit__(self, _ServicerContext servicer_context):
+        self._servicer_context = servicer_context
+        self._agen = None
+
+    async def _async_message_receiver(self):
+        """An async generator that receives messages."""
+        cdef object message
+        while True:
+            message = await self._servicer_context.read()
+            if message is not EOF:
+                yield message
+            else:
+                break
+
+    def __aiter__(self):
+        # Prevents never awaited warning if application never used the async generator
+        if self._agen is None:
+            self._agen = self._async_message_receiver()
+        return self._agen
+
+    async def __anext__(self):
+        return await self.__aiter__().__anext__()
+
+
+async def _handle_stream_unary_rpc(object method_handler,
+                                   RPCState rpc_state,
+                                   object loop):
+    # Creates a dedecated ServicerContext
+    cdef _ServicerContext servicer_context = _ServicerContext(
+        rpc_state,
+        method_handler.request_deserializer,
+        None,
+        loop,
     )
 
-    # Creates a dedecated ServicerContext 
-    cdef _ServicerContext servicer_context = _ServicerContext( 
-        rpc_state, 
-        method_handler.request_deserializer, 
-        method_handler.response_serializer, 
-        loop, 
-    ) 
-
-    # Finishes the application handler 
-    await _finish_handler_with_stream_responses( 
-        rpc_state, 
-        method_handler.unary_stream, 
-        request_message, 
-        servicer_context, 
-        loop, 
+    # Prepares the request generator
+    cdef object request_iterator
+    if _is_async_handler(method_handler.stream_unary):
+        request_iterator = _MessageReceiver(servicer_context)
+    else:
+        request_iterator = async_generator_to_generator(
+            _MessageReceiver(servicer_context),
+            loop
+        )
+
+    # Finishes the application handler
+    await _finish_handler_with_unary_response(
+        rpc_state,
+        method_handler.stream_unary,
+        request_iterator,
+        servicer_context,
+        method_handler.response_serializer,
+        loop
     )
 
 
-cdef class _MessageReceiver: 
-    """Bridge between the async generator API and the reader-writer API.""" 
-
-    def __cinit__(self, _ServicerContext servicer_context): 
-        self._servicer_context = servicer_context 
-        self._agen = None 
-
-    async def _async_message_receiver(self): 
-        """An async generator that receives messages.""" 
-        cdef object message 
-        while True: 
-            message = await self._servicer_context.read() 
-            if message is not EOF: 
-                yield message 
-            else: 
-                break 
- 
-    def __aiter__(self): 
-        # Prevents never awaited warning if application never used the async generator 
-        if self._agen is None: 
-            self._agen = self._async_message_receiver() 
-        return self._agen 
- 
-    async def __anext__(self): 
-        return await self.__aiter__().__anext__() 
- 
- 
-async def _handle_stream_unary_rpc(object method_handler, 
-                                   RPCState rpc_state, 
-                                   object loop): 
-    # Creates a dedecated ServicerContext 
-    cdef _ServicerContext servicer_context = _ServicerContext( 
-        rpc_state, 
-        method_handler.request_deserializer, 
-        None, 
-        loop, 
-    ) 
-
-    # Prepares the request generator 
-    cdef object request_iterator 
-    if _is_async_handler(method_handler.stream_unary): 
-        request_iterator = _MessageReceiver(servicer_context) 
-    else: 
-        request_iterator = async_generator_to_generator( 
-            _MessageReceiver(servicer_context), 
-            loop 
-        ) 
-
-    # Finishes the application handler 
-    await _finish_handler_with_unary_response( 
-        rpc_state, 
-        method_handler.stream_unary, 
-        request_iterator, 
-        servicer_context, 
-        method_handler.response_serializer, 
-        loop 
-    ) 
- 
- 
-async def _handle_stream_stream_rpc(object method_handler, 
-                                    RPCState rpc_state, 
+async def _handle_stream_stream_rpc(object method_handler,
+                                    RPCState rpc_state,
                                     object loop):
-    # Creates a dedecated ServicerContext 
-    cdef _ServicerContext servicer_context = _ServicerContext( 
-        rpc_state, 
-        method_handler.request_deserializer, 
-        method_handler.response_serializer, 
-        loop, 
+    # Creates a dedecated ServicerContext
+    cdef _ServicerContext servicer_context = _ServicerContext(
+        rpc_state,
+        method_handler.request_deserializer,
+        method_handler.response_serializer,
+        loop,
     )
 
-    # Prepares the request generator 
-    cdef object request_iterator 
-    if _is_async_handler(method_handler.stream_stream): 
-        request_iterator = _MessageReceiver(servicer_context) 
-    else: 
-        request_iterator = async_generator_to_generator( 
-            _MessageReceiver(servicer_context), 
-            loop 
-        ) 
-
-    # Finishes the application handler 
-    await _finish_handler_with_stream_responses( 
-        rpc_state, 
-        method_handler.stream_stream, 
-        request_iterator, 
-        servicer_context, 
-        loop, 
-    ) 
-
- 
-async def _handle_exceptions(RPCState rpc_state, object rpc_coro, object loop): 
-    try: 
-        try: 
-            await rpc_coro 
-        except AbortError as e: 
-            # Caught AbortError check if it is the same one 
-            assert rpc_state.abort_exception is e, 'Abort error has been replaced!' 
-            return 
-        else: 
-            # Check if the abort exception got suppressed 
-            if rpc_state.abort_exception is not None: 
-                _LOGGER.error( 
-                    'Abort error unexpectedly suppressed: %s', 
-                    traceback.format_exception(rpc_state.abort_exception) 
-                ) 
-    except (KeyboardInterrupt, SystemExit): 
-        raise 
-    except asyncio.CancelledError: 
-        _LOGGER.debug('RPC cancelled for servicer method [%s]', _decode(rpc_state.method())) 
-    except _ServerStoppedError: 
-        _LOGGER.warning('Aborting method [%s] due to server stop.', _decode(rpc_state.method())) 
-    except ExecuteBatchError: 
-        # If client closed (aka. cancelled), ignore the failed batch operations. 
-        if rpc_state.client_closed: 
-            return 
-        else: 
-            raise 
-    except Exception as e: 
-        _LOGGER.exception('Unexpected [%s] raised by servicer method [%s]' % ( 
-            type(e).__name__, 
-            _decode(rpc_state.method()), 
-        )) 
-        if not rpc_state.status_sent and rpc_state.server._status != AIO_SERVER_STATUS_STOPPED: 
-            # Allows users to raise other types of exception with specified status code 
-            if rpc_state.status_code == StatusCode.ok: 
-                status_code = StatusCode.unknown 
-            else: 
-                status_code = rpc_state.status_code 
- 
-            await _send_error_status_from_server( 
-                rpc_state, 
-                status_code, 
-                'Unexpected %s: %s' % (type(e), e), 
-                rpc_state.trailing_metadata, 
-                rpc_state.create_send_initial_metadata_op_if_not_sent(), 
-                loop 
-            ) 
- 
- 
+    # Prepares the request generator
+    cdef object request_iterator
+    if _is_async_handler(method_handler.stream_stream):
+        request_iterator = _MessageReceiver(servicer_context)
+    else:
+        request_iterator = async_generator_to_generator(
+            _MessageReceiver(servicer_context),
+            loop
+        )
+
+    # Finishes the application handler
+    await _finish_handler_with_stream_responses(
+        rpc_state,
+        method_handler.stream_stream,
+        request_iterator,
+        servicer_context,
+        loop,
+    )
+
+
+async def _handle_exceptions(RPCState rpc_state, object rpc_coro, object loop):
+    try:
+        try:
+            await rpc_coro
+        except AbortError as e:
+            # Caught AbortError check if it is the same one
+            assert rpc_state.abort_exception is e, 'Abort error has been replaced!'
+            return
+        else:
+            # Check if the abort exception got suppressed
+            if rpc_state.abort_exception is not None:
+                _LOGGER.error(
+                    'Abort error unexpectedly suppressed: %s',
+                    traceback.format_exception(rpc_state.abort_exception)
+                )
+    except (KeyboardInterrupt, SystemExit):
+        raise
+    except asyncio.CancelledError:
+        _LOGGER.debug('RPC cancelled for servicer method [%s]', _decode(rpc_state.method()))
+    except _ServerStoppedError:
+        _LOGGER.warning('Aborting method [%s] due to server stop.', _decode(rpc_state.method()))
+    except ExecuteBatchError:
+        # If client closed (aka. cancelled), ignore the failed batch operations.
+        if rpc_state.client_closed:
+            return
+        else:
+            raise
+    except Exception as e:
+        _LOGGER.exception('Unexpected [%s] raised by servicer method [%s]' % (
+            type(e).__name__,
+            _decode(rpc_state.method()),
+        ))
+        if not rpc_state.status_sent and rpc_state.server._status != AIO_SERVER_STATUS_STOPPED:
+            # Allows users to raise other types of exception with specified status code
+            if rpc_state.status_code == StatusCode.ok:
+                status_code = StatusCode.unknown
+            else:
+                status_code = rpc_state.status_code
+
+            await _send_error_status_from_server(
+                rpc_state,
+                status_code,
+                'Unexpected %s: %s' % (type(e), e),
+                rpc_state.trailing_metadata,
+                rpc_state.create_send_initial_metadata_op_if_not_sent(),
+                loop
+            )
+
+
 async def _handle_cancellation_from_core(object rpc_task,
-                                         RPCState rpc_state, 
-                                         object loop): 
+                                         RPCState rpc_state,
+                                         object loop):
     cdef ReceiveCloseOnServerOperation op = ReceiveCloseOnServerOperation(_EMPTY_FLAG)
     cdef tuple ops = (op,)
- 
-    # Awaits cancellation from peer. 
-    await execute_batch(rpc_state, ops, loop) 
-    rpc_state.client_closed = True 
-    # If 1) received cancel signal; 2) the Task is not finished; 3) the server 
-    # wasn't replying final status. For condition 3, it might cause inaccurate 
-    # log that an RPC is both aborted and cancelled. 
-    if op.cancelled() and not rpc_task.done() and not rpc_state.status_sent: 
-        # Injects `CancelledError` to halt the RPC coroutine 
+
+    # Awaits cancellation from peer.
+    await execute_batch(rpc_state, ops, loop)
+    rpc_state.client_closed = True
+    # If 1) received cancel signal; 2) the Task is not finished; 3) the server
+    # wasn't replying final status. For condition 3, it might cause inaccurate
+    # log that an RPC is both aborted and cancelled.
+    if op.cancelled() and not rpc_task.done() and not rpc_state.status_sent:
+        # Injects `CancelledError` to halt the RPC coroutine
         rpc_task.cancel()
 
 
-async def _schedule_rpc_coro(object rpc_coro, 
-                             RPCState rpc_state, 
-                             object loop): 
-    # Schedules the RPC coroutine. 
-    cdef object rpc_task = loop.create_task(_handle_exceptions( 
-        rpc_state, 
-        rpc_coro, 
-        loop, 
-    )) 
-    await _handle_cancellation_from_core(rpc_task, rpc_state, loop) 
- 
- 
-async def _handle_rpc(list generic_handlers, tuple interceptors, 
-                      RPCState rpc_state, object loop): 
-    cdef object method_handler 
-    # Finds the method handler (application logic) 
-    method_handler = await _find_method_handler( 
-        rpc_state.method().decode(), 
-        rpc_state.invocation_metadata(), 
-        generic_handlers, 
-        interceptors, 
-    ) 
-    if method_handler is None: 
-        rpc_state.status_sent = True 
-        await _send_error_status_from_server( 
-            rpc_state, 
-            StatusCode.unimplemented, 
-            'Method not found!', 
-            _IMMUTABLE_EMPTY_METADATA, 
-            rpc_state.create_send_initial_metadata_op_if_not_sent(), 
-            loop 
-        ) 
-        return 
- 
-    # Handles unary-unary case 
-    if not method_handler.request_streaming and not method_handler.response_streaming: 
-        await _handle_unary_unary_rpc(method_handler, 
-                                      rpc_state, 
-                                      loop) 
-        return 
- 
-    # Handles unary-stream case 
-    if not method_handler.request_streaming and method_handler.response_streaming: 
-        await _handle_unary_stream_rpc(method_handler, 
-                                       rpc_state, 
-                                       loop) 
-        return 
- 
-    # Handles stream-unary case 
-    if method_handler.request_streaming and not method_handler.response_streaming: 
-        await _handle_stream_unary_rpc(method_handler, 
-                                       rpc_state, 
-                                       loop) 
-        return 
- 
-    # Handles stream-stream case 
-    if method_handler.request_streaming and method_handler.response_streaming: 
-        await _handle_stream_stream_rpc(method_handler, 
-                                        rpc_state, 
-                                        loop) 
-        return 
- 
- 
-class _RequestCallError(Exception): pass 
- 
-cdef CallbackFailureHandler REQUEST_CALL_FAILURE_HANDLER = CallbackFailureHandler( 
-    'grpc_server_request_call', None, _RequestCallError) 
- 
- 
+async def _schedule_rpc_coro(object rpc_coro,
+                             RPCState rpc_state,
+                             object loop):
+    # Schedules the RPC coroutine.
+    cdef object rpc_task = loop.create_task(_handle_exceptions(
+        rpc_state,
+        rpc_coro,
+        loop,
+    ))
+    await _handle_cancellation_from_core(rpc_task, rpc_state, loop)
+
+
+async def _handle_rpc(list generic_handlers, tuple interceptors,
+                      RPCState rpc_state, object loop):
+    cdef object method_handler
+    # Finds the method handler (application logic)
+    method_handler = await _find_method_handler(
+        rpc_state.method().decode(),
+        rpc_state.invocation_metadata(),
+        generic_handlers,
+        interceptors,
+    )
+    if method_handler is None:
+        rpc_state.status_sent = True
+        await _send_error_status_from_server(
+            rpc_state,
+            StatusCode.unimplemented,
+            'Method not found!',
+            _IMMUTABLE_EMPTY_METADATA,
+            rpc_state.create_send_initial_metadata_op_if_not_sent(),
+            loop
+        )
+        return
+
+    # Handles unary-unary case
+    if not method_handler.request_streaming and not method_handler.response_streaming:
+        await _handle_unary_unary_rpc(method_handler,
+                                      rpc_state,
+                                      loop)
+        return
+
+    # Handles unary-stream case
+    if not method_handler.request_streaming and method_handler.response_streaming:
+        await _handle_unary_stream_rpc(method_handler,
+                                       rpc_state,
+                                       loop)
+        return
+
+    # Handles stream-unary case
+    if method_handler.request_streaming and not method_handler.response_streaming:
+        await _handle_stream_unary_rpc(method_handler,
+                                       rpc_state,
+                                       loop)
+        return
+
+    # Handles stream-stream case
+    if method_handler.request_streaming and method_handler.response_streaming:
+        await _handle_stream_stream_rpc(method_handler,
+                                        rpc_state,
+                                        loop)
+        return
+
+
+class _RequestCallError(Exception): pass
+
+cdef CallbackFailureHandler REQUEST_CALL_FAILURE_HANDLER = CallbackFailureHandler(
+    'grpc_server_request_call', None, _RequestCallError)
+
+
 cdef CallbackFailureHandler SERVER_SHUTDOWN_FAILURE_HANDLER = CallbackFailureHandler(
     'grpc_server_shutdown_and_notify',
-    None, 
-    InternalError) 
+    None,
+    InternalError)
 
 
 cdef class AioServer:
 
     def __init__(self, loop, thread_pool, generic_handlers, interceptors,
-                 options, maximum_concurrent_rpcs): 
-        init_grpc_aio() 
+                 options, maximum_concurrent_rpcs):
+        init_grpc_aio()
         # NOTE(lidiz) Core objects won't be deallocated automatically.
         # If AioServer.shutdown is not called, those objects will leak.
         self._server = Server(options)
         grpc_server_register_completion_queue(
             self._server.c_server,
-            global_completion_queue(), 
+            global_completion_queue(),
             NULL
         )
 
@@ -805,53 +805,53 @@ cdef class AioServer:
         self._shutdown_completed = self._loop.create_future()
         self._shutdown_callback_wrapper = CallbackWrapper(
             self._shutdown_completed,
-            self._loop, 
+            self._loop,
             SERVER_SHUTDOWN_FAILURE_HANDLER)
         self._crash_exception = None
 
         if interceptors:
-            self._interceptors = interceptors 
-        else: 
-            self._interceptors = () 
- 
-        self._thread_pool = thread_pool 
- 
+            self._interceptors = interceptors
+        else:
+            self._interceptors = ()
+
+        self._thread_pool = thread_pool
+
         if maximum_concurrent_rpcs:
             raise NotImplementedError()
 
-    def add_generic_rpc_handlers(self, object generic_rpc_handlers): 
-        self._generic_handlers.extend(generic_rpc_handlers) 
+    def add_generic_rpc_handlers(self, object generic_rpc_handlers):
+        self._generic_handlers.extend(generic_rpc_handlers)
 
     def add_insecure_port(self, address):
         return self._server.add_http2_port(address)
 
     def add_secure_port(self, address, server_credentials):
         return self._server.add_http2_port(address,
-                                           server_credentials._credentials) 
-
-    async def _request_call(self): 
-        cdef grpc_call_error error 
-        cdef RPCState rpc_state = RPCState(self) 
-        cdef object future = self._loop.create_future() 
-        cdef CallbackWrapper wrapper = CallbackWrapper( 
-            future, 
-            self._loop, 
-            REQUEST_CALL_FAILURE_HANDLER) 
-        error = grpc_server_request_call( 
-            self._server.c_server, &rpc_state.call, &rpc_state.details, 
-            &rpc_state.request_metadata, 
-            global_completion_queue(), global_completion_queue(), 
-            wrapper.c_functor() 
-        ) 
-        if error != GRPC_CALL_OK: 
-            raise InternalError("Error in grpc_server_request_call: %s" % error) 
- 
-        await future 
-        return rpc_state 
- 
+                                           server_credentials._credentials)
+
+    async def _request_call(self):
+        cdef grpc_call_error error
+        cdef RPCState rpc_state = RPCState(self)
+        cdef object future = self._loop.create_future()
+        cdef CallbackWrapper wrapper = CallbackWrapper(
+            future,
+            self._loop,
+            REQUEST_CALL_FAILURE_HANDLER)
+        error = grpc_server_request_call(
+            self._server.c_server, &rpc_state.call, &rpc_state.details,
+            &rpc_state.request_metadata,
+            global_completion_queue(), global_completion_queue(),
+            wrapper.c_functor()
+        )
+        if error != GRPC_CALL_OK:
+            raise InternalError("Error in grpc_server_request_call: %s" % error)
+
+        await future
+        return rpc_state
+
     async def _server_main_loop(self,
                                 object server_started):
-        self._server.start(backup_queue=False) 
+        self._server.start(backup_queue=False)
         cdef RPCState rpc_state
         server_started.set_result(True)
 
@@ -860,23 +860,23 @@ cdef class AioServer:
             if self._status != AIO_SERVER_STATUS_RUNNING:
                 break
 
-            # Accepts new request from Core 
-            rpc_state = await self._request_call() 
-
-            # Creates the dedicated RPC coroutine. If we schedule it right now, 
-            # there is no guarantee if the cancellation listening coroutine is 
-            # ready or not. So, we should control the ordering by scheduling 
-            # the coroutine onto event loop inside of the cancellation 
-            # coroutine. 
-            rpc_coro = _handle_rpc(self._generic_handlers, 
-                                   self._interceptors, 
-                                   rpc_state, 
-                                   self._loop) 
- 
-            # Fires off a task that listens on the cancellation from client. 
+            # Accepts new request from Core
+            rpc_state = await self._request_call()
+
+            # Creates the dedicated RPC coroutine. If we schedule it right now,
+            # there is no guarantee if the cancellation listening coroutine is
+            # ready or not. So, we should control the ordering by scheduling
+            # the coroutine onto event loop inside of the cancellation
+            # coroutine.
+            rpc_coro = _handle_rpc(self._generic_handlers,
+                                   self._interceptors,
+                                   rpc_state,
+                                   self._loop)
+
+            # Fires off a task that listens on the cancellation from client.
             self._loop.create_task(
-                _schedule_rpc_coro( 
-                    rpc_coro, 
+                _schedule_rpc_coro(
+                    rpc_coro,
                     rpc_state,
                     self._loop
                 )
@@ -895,7 +895,7 @@ cdef class AioServer:
         if self._status == AIO_SERVER_STATUS_RUNNING:
             return
         elif self._status != AIO_SERVER_STATUS_READY:
-            raise UsageError('Server not in ready state') 
+            raise UsageError('Server not in ready state')
 
         self._status = AIO_SERVER_STATUS_RUNNING
         cdef object server_started = self._loop.create_future()
@@ -913,7 +913,7 @@ cdef class AioServer:
         # The shutdown callback won't be called until there is no live RPC.
         grpc_server_shutdown_and_notify(
             self._server.c_server,
-            global_completion_queue(), 
+            global_completion_queue(),
             self._shutdown_callback_wrapper.c_functor())
 
         # Ensures the serving task (coroutine) exits.
@@ -923,7 +923,7 @@ cdef class AioServer:
             pass
 
     async def shutdown(self, grace):
-        """Gracefully shutdown the Core server. 
+        """Gracefully shutdown the Core server.
 
         Application should only call shutdown once.
 
@@ -966,7 +966,7 @@ cdef class AioServer:
                 self._server.is_shutdown = True
                 self._status = AIO_SERVER_STATUS_STOPPED
 
-    async def wait_for_termination(self, object timeout): 
+    async def wait_for_termination(self, object timeout):
         if timeout is None:
             await self._shutdown_completed
         else:
@@ -988,20 +988,20 @@ cdef class AioServer:
         return True
 
     def __dealloc__(self):
-        """Deallocation of Core objects are ensured by Python layer.""" 
-        # TODO(lidiz) if users create server, and then dealloc it immediately. 
-        # There is a potential memory leak of created Core server. 
+        """Deallocation of Core objects are ensured by Python layer."""
+        # TODO(lidiz) if users create server, and then dealloc it immediately.
+        # There is a potential memory leak of created Core server.
         if self._status != AIO_SERVER_STATUS_STOPPED:
-            _LOGGER.debug( 
-                '__dealloc__ called on running server %s with status %d', 
-                self, 
-                self._status 
-            ) 
-        shutdown_grpc_aio() 
- 
-    cdef thread_pool(self): 
-        """Access the thread pool instance.""" 
-        return self._thread_pool 
- 
-    def is_running(self): 
-        return self._status == AIO_SERVER_STATUS_RUNNING 
+            _LOGGER.debug(
+                '__dealloc__ called on running server %s with status %d',
+                self,
+                self._status
+            )
+        shutdown_grpc_aio()
+
+    cdef thread_pool(self):
+        """Access the thread pool instance."""
+        return self._thread_pool
+
+    def is_running(self):
+        return self._status == AIO_SERVER_STATUS_RUNNING
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/channel.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/channel.pyx.pxi
index f0d6c69472..74c7f6c140 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/channel.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/channel.pyx.pxi
@@ -256,8 +256,8 @@ cdef void _call(
         on_success(started_tags)
     else:
       raise ValueError('Cannot invoke RPC: %s' % channel_state.closed_reason)
- 
- 
+
+
 cdef void _process_integrated_call_tag(
     _ChannelState state, _BatchOperationTag tag) except *:
   cdef _CallState call_state = state.integrated_call_states.pop(tag)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/credentials.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/credentials.pxd.pxi
index 44aebc7cbd..ddaedb30bd 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/credentials.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/credentials.pxd.pxi
@@ -102,9 +102,9 @@ cdef class ServerCredentials:
 cdef class LocalChannelCredentials(ChannelCredentials):
 
   cdef grpc_local_connect_type _local_connect_type
- 
- 
-cdef class ALTSChannelCredentials(ChannelCredentials): 
-  cdef grpc_alts_credentials_options *c_options 
- 
-  cdef grpc_channel_credentials *c(self) except * 
+
+
+cdef class ALTSChannelCredentials(ChannelCredentials):
+  cdef grpc_alts_credentials_options *c_options
+
+  cdef grpc_channel_credentials *c(self) except *
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/credentials.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/credentials.pyx.pxi
index 94687a4da9..c75579cc04 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/credentials.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/credentials.pyx.pxi
@@ -14,9 +14,9 @@
 
 
 def _spawn_callback_in_thread(cb_func, args):
-  t = ForkManagedThread(target=cb_func, args=args) 
-  t.setDaemon(True) 
-  t.start() 
+  t = ForkManagedThread(target=cb_func, args=args)
+  t.setDaemon(True)
+  t.start()
 
 async_callback_func = _spawn_callback_in_thread
 
@@ -34,14 +34,14 @@ cdef class CallCredentials:
     raise NotImplementedError()
 
 
-cdef int _get_metadata(void *state, 
-                       grpc_auth_metadata_context context, 
-                       grpc_credentials_plugin_metadata_cb cb, 
-                       void *user_data, 
-                       grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX], 
-                       size_t *num_creds_md, 
-                       grpc_status_code *status, 
-                       const char **error_details) except * with gil: 
+cdef int _get_metadata(void *state,
+                       grpc_auth_metadata_context context,
+                       grpc_credentials_plugin_metadata_cb cb,
+                       void *user_data,
+                       grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
+                       size_t *num_creds_md,
+                       grpc_status_code *status,
+                       const char **error_details) except * with gil:
   cdef size_t metadata_count
   cdef grpc_metadata *c_metadata
   def callback(metadata, grpc_status_code status, bytes error_details):
@@ -75,9 +75,9 @@ cdef class MetadataPluginCallCredentials(CallCredentials):
     c_metadata_plugin.type = self._name
     cpython.Py_INCREF(self._metadata_plugin)
     fork_handlers_and_grpc_init()
-    # TODO(yihuazhang): Expose min_security_level via the Python API so that 
-    # applications can decide what minimum security level their plugins require. 
-    return grpc_metadata_credentials_create_from_plugin(c_metadata_plugin, GRPC_PRIVACY_AND_INTEGRITY, NULL) 
+    # TODO(yihuazhang): Expose min_security_level via the Python API so that
+    # applications can decide what minimum security level their plugins require.
+    return grpc_metadata_credentials_create_from_plugin(c_metadata_plugin, GRPC_PRIVACY_AND_INTEGRITY, NULL)
 
 
 cdef grpc_call_credentials *_composition(call_credentialses):
@@ -351,51 +351,51 @@ def server_credentials_local(grpc_local_connect_type local_connect_type):
   cdef ServerCredentials credentials = ServerCredentials()
   credentials.c_credentials = grpc_local_server_credentials_create(local_connect_type)
   return credentials
+
+
+cdef class ALTSChannelCredentials(ChannelCredentials):
+
+  def __cinit__(self, list service_accounts):
+    self.c_options = grpc_alts_credentials_client_options_create()
+    cdef str account
+    for account in service_accounts:
+      grpc_alts_credentials_client_options_add_target_service_account(self.c_options, account)
  
- 
-cdef class ALTSChannelCredentials(ChannelCredentials): 
- 
-  def __cinit__(self, list service_accounts): 
-    self.c_options = grpc_alts_credentials_client_options_create() 
-    cdef str account 
-    for account in service_accounts: 
-      grpc_alts_credentials_client_options_add_target_service_account(self.c_options, account) 
-  
-  def __dealloc__(self): 
-    if self.c_options != NULL: 
-      grpc_alts_credentials_options_destroy(self.c_options) 
- 
-  cdef grpc_channel_credentials *c(self) except *: 
-    return grpc_alts_credentials_create(self.c_options) 
-     
- 
-def channel_credentials_alts(list service_accounts): 
-  return ALTSChannelCredentials(service_accounts) 
- 
- 
-def server_credentials_alts(): 
-  cdef ServerCredentials credentials = ServerCredentials() 
-  cdef grpc_alts_credentials_options* c_options = grpc_alts_credentials_server_options_create() 
-  credentials.c_credentials = grpc_alts_server_credentials_create(c_options) 
-  # Options can be destroyed as deep copy was performed. 
-  grpc_alts_credentials_options_destroy(c_options) 
-  return credentials 
- 
- 
-cdef class ComputeEngineChannelCredentials(ChannelCredentials): 
-  cdef grpc_channel_credentials* _c_creds 
-  cdef grpc_call_credentials* _call_creds 
- 
-  def __cinit__(self, CallCredentials call_creds): 
-    self._c_creds = NULL 
-    self._call_creds = call_creds.c() 
-    if self._call_creds == NULL: 
-      raise ValueError("Call credentials may not be NULL.") 
- 
-  cdef grpc_channel_credentials *c(self) except *: 
-    self._c_creds = grpc_google_default_credentials_create(self._call_creds) 
-    return self._c_creds 
- 
- 
-def channel_credentials_compute_engine(call_creds): 
-  return ComputeEngineChannelCredentials(call_creds) 
+  def __dealloc__(self):
+    if self.c_options != NULL:
+      grpc_alts_credentials_options_destroy(self.c_options)
+
+  cdef grpc_channel_credentials *c(self) except *:
+    return grpc_alts_credentials_create(self.c_options)
+    
+
+def channel_credentials_alts(list service_accounts):
+  return ALTSChannelCredentials(service_accounts)
+
+
+def server_credentials_alts():
+  cdef ServerCredentials credentials = ServerCredentials()
+  cdef grpc_alts_credentials_options* c_options = grpc_alts_credentials_server_options_create()
+  credentials.c_credentials = grpc_alts_server_credentials_create(c_options)
+  # Options can be destroyed as deep copy was performed.
+  grpc_alts_credentials_options_destroy(c_options)
+  return credentials
+
+
+cdef class ComputeEngineChannelCredentials(ChannelCredentials):
+  cdef grpc_channel_credentials* _c_creds
+  cdef grpc_call_credentials* _call_creds
+
+  def __cinit__(self, CallCredentials call_creds):
+    self._c_creds = NULL
+    self._call_creds = call_creds.c()
+    if self._call_creds == NULL:
+      raise ValueError("Call credentials may not be NULL.")
+
+  cdef grpc_channel_credentials *c(self) except *:
+    self._c_creds = grpc_google_default_credentials_create(self._call_creds)
+    return self._c_creds
+
+
+def channel_credentials_compute_engine(call_creds):
+  return ComputeEngineChannelCredentials(call_creds)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/fork_posix.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/fork_posix.pyx.pxi
index 9cd7b1b3b9..53657e8b1a 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/fork_posix.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/fork_posix.pyx.pxi
@@ -27,7 +27,7 @@ _TRUE_VALUES = ['yes',  'Yes',  'YES', 'true', 'True', 'TRUE', '1']
 # must  not block and should execute quickly.
 #
 # This flag is not supported on Windows.
-# This flag is also not supported for non-native IO manager. 
+# This flag is also not supported for non-native IO manager.
 _GRPC_ENABLE_FORK_SUPPORT = (
     os.environ.get('GRPC_ENABLE_FORK_SUPPORT', '0')
         .lower() in _TRUE_VALUES)
@@ -94,8 +94,8 @@ def fork_handlers_and_grpc_init():
                 _fork_state.fork_handler_registered = True
 
 
- 
- 
+
+
 class ForkManagedThread(object):
     def __init__(self, target, args=()):
         if _GRPC_ENABLE_FORK_SUPPORT:
@@ -104,9 +104,9 @@ class ForkManagedThread(object):
                     target(*args)
                 finally:
                     _fork_state.active_thread_count.decrement()
-            self._thread = threading.Thread(target=_run_with_context(managed_target), args=args) 
+            self._thread = threading.Thread(target=_run_with_context(managed_target), args=args)
         else:
-            self._thread = threading.Thread(target=_run_with_context(target), args=args) 
+            self._thread = threading.Thread(target=_run_with_context(target), args=args)
 
     def setDaemon(self, daemonic):
         self._thread.daemon = daemonic
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/fork_windows.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/fork_windows.pyx.pxi
index aba4d4c28f..67aaf4d033 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/fork_windows.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/fork_windows.pyx.pxi
@@ -21,7 +21,7 @@ def fork_handlers_and_grpc_init():
 
 class ForkManagedThread(object):
     def __init__(self, target, args=()):
-        self._thread = threading.Thread(target=_run_with_context(target), args=args) 
+        self._thread = threading.Thread(target=_run_with_context(target), args=args)
 
     def setDaemon(self, daemonic):
         self._thread.daemon = daemonic
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi
index a0a34ff5ba..54eb7fdffc 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi
@@ -434,13 +434,13 @@ cdef extern from "grpc/grpc_security.h":
     GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY
     GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY
 
-  ctypedef enum grpc_security_level: 
-    GRPC_SECURITY_MIN 
-    GRPC_SECURITY_NONE = GRPC_SECURITY_MIN 
-    GRPC_INTEGRITY_ONLY 
-    GRPC_PRIVACY_AND_INTEGRITY 
-    GRPC_SECURITY_MAX = GRPC_PRIVACY_AND_INTEGRITY 
- 
+  ctypedef enum grpc_security_level:
+    GRPC_SECURITY_MIN
+    GRPC_SECURITY_NONE = GRPC_SECURITY_MIN
+    GRPC_INTEGRITY_ONLY
+    GRPC_PRIVACY_AND_INTEGRITY
+    GRPC_SECURITY_MAX = GRPC_PRIVACY_AND_INTEGRITY
+
   ctypedef enum grpc_ssl_certificate_config_reload_status:
     GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED
     GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW
@@ -505,7 +505,7 @@ cdef extern from "grpc/grpc_security.h":
   void grpc_set_ssl_roots_override_callback(
       grpc_ssl_roots_override_callback cb) nogil
 
-  grpc_channel_credentials *grpc_google_default_credentials_create(grpc_call_credentials* call_credentials) nogil 
+  grpc_channel_credentials *grpc_google_default_credentials_create(grpc_call_credentials* call_credentials) nogil
   grpc_channel_credentials *grpc_ssl_credentials_create(
       const char *pem_root_certs, grpc_ssl_pem_key_cert_pair *pem_key_cert_pair,
       verify_peer_options *verify_options, void *reserved) nogil
@@ -570,7 +570,7 @@ cdef extern from "grpc/grpc_security.h":
     const char *type
 
   grpc_call_credentials *grpc_metadata_credentials_create_from_plugin(
-      grpc_metadata_credentials_plugin plugin, grpc_security_level min_security_level, void *reserved) nogil 
+      grpc_metadata_credentials_plugin plugin, grpc_security_level min_security_level, void *reserved) nogil
 
   ctypedef struct grpc_auth_property_iterator:
     pass
@@ -607,22 +607,22 @@ cdef extern from "grpc/grpc_security.h":
   grpc_server_credentials *grpc_local_server_credentials_create(
     grpc_local_connect_type type)
 
-  ctypedef struct grpc_alts_credentials_options: 
-    # We don't care about the internals (and in fact don't know them) 
-    pass 
-  
-  grpc_channel_credentials *grpc_alts_credentials_create( 
-    const grpc_alts_credentials_options *options) 
-  grpc_server_credentials *grpc_alts_server_credentials_create( 
-    const grpc_alts_credentials_options *options) 
-
-  grpc_alts_credentials_options* grpc_alts_credentials_client_options_create() 
-  grpc_alts_credentials_options* grpc_alts_credentials_server_options_create() 
-  void grpc_alts_credentials_options_destroy(grpc_alts_credentials_options *options) 
-  void grpc_alts_credentials_client_options_add_target_service_account(grpc_alts_credentials_options *options, const char *service_account) 
- 
- 
+  ctypedef struct grpc_alts_credentials_options:
+    # We don't care about the internals (and in fact don't know them)
+    pass
  
+  grpc_channel_credentials *grpc_alts_credentials_create(
+    const grpc_alts_credentials_options *options)
+  grpc_server_credentials *grpc_alts_server_credentials_create(
+    const grpc_alts_credentials_options *options)
+
+  grpc_alts_credentials_options* grpc_alts_credentials_client_options_create()
+  grpc_alts_credentials_options* grpc_alts_credentials_server_options_create()
+  void grpc_alts_credentials_options_destroy(grpc_alts_credentials_options *options)
+  void grpc_alts_credentials_client_options_add_target_service_account(grpc_alts_credentials_options *options, const char *service_account)
+
+
+
 cdef extern from "grpc/compression.h":
 
   ctypedef enum grpc_compression_algorithm:
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pxd.pxi
index 969c2855ce..bd1d73145b 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pxd.pxi
@@ -37,5 +37,5 @@ cdef class SocketWrapper:
 
 cdef class ResolveWrapper:
   cdef grpc_custom_resolver *c_resolver
-  cdef const char* c_host 
-  cdef const char* c_port 
+  cdef const char* c_host
+  cdef const char* c_port
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pyx.pxi
index 0001e10d30..0f693ec691 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_gevent.pyx.pxi
@@ -283,14 +283,14 @@ cdef socket_resolve_async_cython(ResolveWrapper resolve_wrapper):
 def socket_resolve_async_python(resolve_wrapper):
   socket_resolve_async_cython(resolve_wrapper)
 
-cdef void socket_resolve_async(grpc_custom_resolver* r, const char* host, const char* port) with gil: 
+cdef void socket_resolve_async(grpc_custom_resolver* r, const char* host, const char* port) with gil:
   rw = ResolveWrapper()
   rw.c_resolver = r
   rw.c_host = host
   rw.c_port = port
   _spawn_greenlet(socket_resolve_async_python, rw)
 
-cdef grpc_error* socket_resolve(const char* host, const char* port, 
+cdef grpc_error* socket_resolve(const char* host, const char* port,
                                 grpc_resolved_addresses** res) with gil:
     try:
       result = gevent_socket.getaddrinfo(host, port)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_string.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_string.pyx.pxi
index f1e415f9e3..5c1e0679a9 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_string.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/grpc_string.pyx.pxi
@@ -35,7 +35,7 @@ cdef bytes _encode(object string_or_none):
   elif isinstance(string_or_none, (bytes,)):
     return <bytes>string_or_none
   elif isinstance(string_or_none, (unicode,)):
-    return string_or_none.encode('utf8') 
+    return string_or_none.encode('utf8')
   else:
     raise TypeError('Expected str, not {}'.format(type(string_or_none)))
 
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/iomgr.pxd.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/iomgr.pxd.pxi
index 461251edb3..0c5a4e5763 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/iomgr.pxd.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/iomgr.pxd.pxi
@@ -13,9 +13,9 @@
 # limitations under the License.
 # distutils: language=c++
 
-from libcpp cimport bool as bool_t 
-from libcpp.string cimport string as cppstring 
- 
+from libcpp cimport bool as bool_t
+from libcpp.string cimport string as cppstring
+
 cdef extern from "grpc/impl/codegen/slice.h":
   struct grpc_slice_buffer:
     int count
@@ -49,16 +49,16 @@ cdef extern from "src/core/lib/iomgr/resolve_address_custom.h":
     pass
 
   struct grpc_custom_resolver_vtable:
-    grpc_error* (*resolve)(const char* host, const char* port, grpc_resolved_addresses** res); 
-    void (*resolve_async)(grpc_custom_resolver* resolver, const char* host, const char* port); 
+    grpc_error* (*resolve)(const char* host, const char* port, grpc_resolved_addresses** res);
+    void (*resolve_async)(grpc_custom_resolver* resolver, const char* host, const char* port);
 
   void grpc_custom_resolve_callback(grpc_custom_resolver* resolver,
                                     grpc_resolved_addresses* result,
                                     grpc_error* error);
 
 cdef extern from "src/core/lib/iomgr/tcp_custom.h":
-  cdef int GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT 
- 
+  cdef int GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT
+
   struct grpc_custom_socket:
     void* impl
     # We don't care about the rest of the fields
@@ -121,8 +121,8 @@ cdef extern from "src/core/lib/iomgr/iomgr_custom.h":
 
 cdef extern from "src/core/lib/iomgr/sockaddr_utils.h":
   int grpc_sockaddr_get_port(const grpc_resolved_address *addr);
-  cppstring grpc_sockaddr_to_string(const grpc_resolved_address *addr, 
-                                    bool_t normalize); 
+  cppstring grpc_sockaddr_to_string(const grpc_resolved_address *addr,
+                                    bool_t normalize);
   void grpc_string_to_sockaddr(grpc_resolved_address *out, char* addr, int port);
   int grpc_sockaddr_set_port(const grpc_resolved_address *resolved_addr,
                              int port)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/iomgr.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/iomgr.pyx.pxi
index c3036bc727..3d6bb24f9a 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/iomgr.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/iomgr.pyx.pxi
@@ -15,7 +15,7 @@
 
 from libc cimport string
 from libc.stdlib cimport malloc
-from libcpp.string cimport string as cppstring 
+from libcpp.string cimport string as cppstring
 
 cdef grpc_error* grpc_error_none():
   return <grpc_error*>0
@@ -26,10 +26,10 @@ cdef grpc_error* socket_error(str syscall, str err):
   return grpc_socket_error(error_bytes)
 
 cdef resolved_addr_to_tuple(grpc_resolved_address* address):
-  cdef cppstring res_str 
+  cdef cppstring res_str
   port = grpc_sockaddr_get_port(address)
-  res_str = grpc_sockaddr_to_string(address, False) 
-  byte_str = _decode(res_str) 
+  res_str = grpc_sockaddr_to_string(address, False)
+  byte_str = _decode(res_str)
   if byte_str.endswith(':' + str(port)):
     byte_str = byte_str[:(0 - len(str(port)) - 1)]
   byte_str = byte_str.lstrip('[')
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/metadata.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/metadata.pyx.pxi
index 033608cee6..b2dd1e3380 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/metadata.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/metadata.pyx.pxi
@@ -41,11 +41,11 @@ cdef void _store_c_metadata(
       for index, (key, value) in enumerate(metadata):
         encoded_key = _encode(key)
         encoded_value = value if encoded_key[-4:] == b'-bin' else _encode(value)
-        if not isinstance(encoded_value, bytes): 
-          raise TypeError('Binary metadata key="%s" expected bytes, got %s' % ( 
-            key, 
-            type(encoded_value) 
-          )) 
+        if not isinstance(encoded_value, bytes):
+          raise TypeError('Binary metadata key="%s" expected bytes, got %s' % (
+            key,
+            type(encoded_value)
+          ))
         c_metadata[0][index].key = _slice_from_bytes(encoded_key)
         c_metadata[0][index].value = _slice_from_bytes(encoded_value)
 
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/operation.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/operation.pyx.pxi
index 9ed2b8e465..3f3fd75407 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/operation.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/operation.pyx.pxi
@@ -49,10 +49,10 @@ cdef class SendInitialMetadataOperation(Operation):
 cdef class SendMessageOperation(Operation):
 
   def __cinit__(self, bytes message, int flags):
-    if message is None: 
-      self._message = b'' 
-    else: 
-      self._message = message 
+    if message is None:
+      self._message = b''
+    else:
+      self._message = message
     self._flags = flags
 
   def type(self):
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/server.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/server.pyx.pxi
index f5e4ffc543..eff95c4f29 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/server.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/server.pyx.pxi
@@ -118,7 +118,7 @@ cdef class Server:
 
   def cancel_all_calls(self):
     if not self.is_shutting_down:
-      raise UsageError("the server must be shutting down to cancel all calls") 
+      raise UsageError("the server must be shutting down to cancel all calls")
     elif self.is_shutdown:
       return
     else:
@@ -136,7 +136,7 @@ cdef class Server:
         pass
       elif not self.is_shutting_down:
         if self.backup_shutdown_queue is None:
-          raise InternalError('Server shutdown failed: no completion queue.') 
+          raise InternalError('Server shutdown failed: no completion queue.')
         else:
           # the user didn't call shutdown - use our backup queue
           self._c_shutdown(self.backup_shutdown_queue, None)
@@ -148,9 +148,9 @@ cdef class Server:
         # much but repeatedly release the GIL and wait
         while not self.is_shutdown:
           time.sleep(0)
-      with nogil: 
-        grpc_server_destroy(self.c_server) 
-        self.c_server = NULL 
+      with nogil:
+        grpc_server_destroy(self.c_server)
+        self.c_server = NULL
 
   def __dealloc__(self):
     if self.c_server == NULL:
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/thread.pyx.pxi b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/thread.pyx.pxi
index d745c341b6..be4cb8b9a8 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/thread.pyx.pxi
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/_cygrpc/thread.pyx.pxi
@@ -1,59 +1,59 @@
-# Copyright 2020 The gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
- 
-def _contextvars_supported(): 
-    """Determines if the contextvars module is supported. 
- 
-    We use a 'try it and see if it works approach' here rather than predicting 
-    based on interpreter version in order to support older interpreters that 
-    may have a backported module based on, e.g. `threading.local`. 
- 
-    Returns: 
-      A bool indicating whether `contextvars` are supported in the current 
-      environment. 
-    """ 
-    try: 
-        import contextvars 
-        return True 
-    except ImportError: 
-        return False 
- 
- 
-def _run_with_context(target): 
-    """Runs a callable with contextvars propagated. 
- 
-    If contextvars are supported, the calling thread's context will be copied 
-    and propagated. If they are not supported, this function is equivalent 
-    to the identity function. 
- 
-    Args: 
-      target: A callable object to wrap. 
-    Returns: 
-      A callable object with the same signature as `target` but with 
-        contextvars propagated. 
-    """ 
- 
- 
-if _contextvars_supported(): 
-    import contextvars 
-    def _run_with_context(target): 
-        ctx = contextvars.copy_context() 
-        def _run(*args): 
-            ctx.run(target, *args) 
-        return _run 
-else: 
-    def _run_with_context(target): 
-        def _run(*args): 
-            target(*args) 
-        return _run 
+# Copyright 2020 The gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+def _contextvars_supported():
+    """Determines if the contextvars module is supported.
+
+    We use a 'try it and see if it works approach' here rather than predicting
+    based on interpreter version in order to support older interpreters that
+    may have a backported module based on, e.g. `threading.local`.
+
+    Returns:
+      A bool indicating whether `contextvars` are supported in the current
+      environment.
+    """
+    try:
+        import contextvars
+        return True
+    except ImportError:
+        return False
+
+
+def _run_with_context(target):
+    """Runs a callable with contextvars propagated.
+
+    If contextvars are supported, the calling thread's context will be copied
+    and propagated. If they are not supported, this function is equivalent
+    to the identity function.
+
+    Args:
+      target: A callable object to wrap.
+    Returns:
+      A callable object with the same signature as `target` but with
+        contextvars propagated.
+    """
+
+
+if _contextvars_supported():
+    import contextvars
+    def _run_with_context(target):
+        ctx = contextvars.copy_context()
+        def _run(*args):
+            ctx.run(target, *args)
+        return _run
+else:
+    def _run_with_context(target):
+        def _run(*args):
+            target(*args)
+        return _run
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/cygrpc.pxd b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/cygrpc.pxd
index 76e100cc7a..166be37022 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/cygrpc.pxd
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/cygrpc.pxd
@@ -13,8 +13,8 @@
 # limitations under the License.
 # distutils: language=c++
 
-cimport cpython 
- 
+cimport cpython
+
 include "_cygrpc/grpc.pxi"
 
 include "_cygrpc/arguments.pxd.pxi"
@@ -45,8 +45,8 @@ IF UNAME_SYSNAME != "Windows":
 include "_cygrpc/aio/iomgr/socket.pxd.pxi"
 include "_cygrpc/aio/iomgr/timer.pxd.pxi"
 include "_cygrpc/aio/iomgr/resolver.pxd.pxi"
-include "_cygrpc/aio/completion_queue.pxd.pxi" 
-include "_cygrpc/aio/rpc_status.pxd.pxi" 
+include "_cygrpc/aio/completion_queue.pxd.pxi"
+include "_cygrpc/aio/rpc_status.pxd.pxi"
 include "_cygrpc/aio/grpc_aio.pxd.pxi"
 include "_cygrpc/aio/callback_common.pxd.pxi"
 include "_cygrpc/aio/call.pxd.pxi"
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/cygrpc.pyx b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/cygrpc.pyx
index 1c5cd48a49..8d355c6fbb 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_cython/cygrpc.pyx
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_cython/cygrpc.pyx
@@ -15,14 +15,14 @@
 
 cimport cpython
 
-import logging 
-import os 
+import logging
+import os
 import sys
-import threading 
-import time 
- 
-import grpc 
- 
+import threading
+import time
+
+import grpc
+
 try:
     import asyncio
 except ImportError:
@@ -31,9 +31,9 @@ except ImportError:
     # Asyncio package is not available we just skip it.
     pass
 
-# The only copy of Python logger for the Cython extension 
-_LOGGER = logging.getLogger(__name__) 
- 
+# The only copy of Python logger for the Cython extension
+_LOGGER = logging.getLogger(__name__)
+
 # TODO(atash): figure out why the coverage tool gets confused about the Cython
 # coverage plugin when the following files don't have a '.pxi' suffix.
 include "_cygrpc/grpc_string.pyx.pxi"
@@ -59,8 +59,8 @@ include "_cygrpc/iomgr.pyx.pxi"
 
 include "_cygrpc/grpc_gevent.pyx.pxi"
 
-include "_cygrpc/thread.pyx.pxi" 
- 
+include "_cygrpc/thread.pyx.pxi"
+
 IF UNAME_SYSNAME == "Windows":
     include "_cygrpc/fork_windows.pyx.pxi"
 ELSE:
@@ -71,10 +71,10 @@ include "_cygrpc/aio/iomgr/iomgr.pyx.pxi"
 include "_cygrpc/aio/iomgr/socket.pyx.pxi"
 include "_cygrpc/aio/iomgr/timer.pyx.pxi"
 include "_cygrpc/aio/iomgr/resolver.pyx.pxi"
-include "_cygrpc/aio/common.pyx.pxi" 
-include "_cygrpc/aio/rpc_status.pyx.pxi" 
-include "_cygrpc/aio/completion_queue.pyx.pxi" 
-include "_cygrpc/aio/callback_common.pyx.pxi" 
+include "_cygrpc/aio/common.pyx.pxi"
+include "_cygrpc/aio/rpc_status.pyx.pxi"
+include "_cygrpc/aio/completion_queue.pyx.pxi"
+include "_cygrpc/aio/callback_common.pyx.pxi"
 include "_cygrpc/aio/grpc_aio.pyx.pxi"
 include "_cygrpc/aio/call.pyx.pxi"
 include "_cygrpc/aio/channel.pyx.pxi"
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_grpcio_metadata.py b/contrib/libs/grpc/src/python/grpcio/grpc/_grpcio_metadata.py
index 25c22febd5..f5d0668407 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_grpcio_metadata.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_grpcio_metadata.py
@@ -14,4 +14,4 @@
 
 # AUTO-GENERATED FROM `$REPO_ROOT/templates/src/python/grpcio/grpc/_grpcio_metadata.py.template`!!!
 
-__version__ = """1.33.2""" 
+__version__ = """1.33.2"""
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_interceptor.py b/contrib/libs/grpc/src/python/grpcio/grpc/_interceptor.py
index 1d80185b7e..ee63cb3145 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_interceptor.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_interceptor.py
@@ -213,12 +213,12 @@ class _UnaryUnaryMultiCallable(grpc.UnaryUnaryMultiCallable):
                  credentials=None,
                  wait_for_ready=None,
                  compression=None):
-        response, ignored_call = self._with_call(request, 
-                                                 timeout=timeout, 
-                                                 metadata=metadata, 
-                                                 credentials=credentials, 
-                                                 wait_for_ready=wait_for_ready, 
-                                                 compression=compression) 
+        response, ignored_call = self._with_call(request,
+                                                 timeout=timeout,
+                                                 metadata=metadata,
+                                                 credentials=credentials,
+                                                 wait_for_ready=wait_for_ready,
+                                                 compression=compression)
         return response
 
     def _with_call(self,
@@ -251,9 +251,9 @@ class _UnaryUnaryMultiCallable(grpc.UnaryUnaryMultiCallable):
             except Exception as exception:  # pylint:disable=broad-except
                 return _FailureOutcome(exception, sys.exc_info()[2])
 
-        call = self._interceptor.intercept_unary_unary(continuation, 
-                                                       client_call_details, 
-                                                       request) 
+        call = self._interceptor.intercept_unary_unary(continuation,
+                                                       client_call_details,
+                                                       request)
         return call.result(), call
 
     def with_call(self,
@@ -263,12 +263,12 @@ class _UnaryUnaryMultiCallable(grpc.UnaryUnaryMultiCallable):
                   credentials=None,
                   wait_for_ready=None,
                   compression=None):
-        return self._with_call(request, 
-                               timeout=timeout, 
-                               metadata=metadata, 
-                               credentials=credentials, 
-                               wait_for_ready=wait_for_ready, 
-                               compression=compression) 
+        return self._with_call(request,
+                               timeout=timeout,
+                               metadata=metadata,
+                               credentials=credentials,
+                               wait_for_ready=wait_for_ready,
+                               compression=compression)
 
     def future(self,
                request,
@@ -324,12 +324,12 @@ class _UnaryStreamMultiCallable(grpc.UnaryStreamMultiCallable):
              new_wait_for_ready,
              new_compression) = (_unwrap_client_call_details(
                  new_details, client_call_details))
-            return self._thunk(new_method)(request, 
-                                           timeout=new_timeout, 
-                                           metadata=new_metadata, 
-                                           credentials=new_credentials, 
-                                           wait_for_ready=new_wait_for_ready, 
-                                           compression=new_compression) 
+            return self._thunk(new_method)(request,
+                                           timeout=new_timeout,
+                                           metadata=new_metadata,
+                                           credentials=new_credentials,
+                                           wait_for_ready=new_wait_for_ready,
+                                           compression=new_compression)
 
         try:
             return self._interceptor.intercept_unary_stream(
@@ -352,12 +352,12 @@ class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
                  credentials=None,
                  wait_for_ready=None,
                  compression=None):
-        response, ignored_call = self._with_call(request_iterator, 
-                                                 timeout=timeout, 
-                                                 metadata=metadata, 
-                                                 credentials=credentials, 
-                                                 wait_for_ready=wait_for_ready, 
-                                                 compression=compression) 
+        response, ignored_call = self._with_call(request_iterator,
+                                                 timeout=timeout,
+                                                 metadata=metadata,
+                                                 credentials=credentials,
+                                                 wait_for_ready=wait_for_ready,
+                                                 compression=compression)
         return response
 
     def _with_call(self,
@@ -390,9 +390,9 @@ class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
             except Exception as exception:  # pylint:disable=broad-except
                 return _FailureOutcome(exception, sys.exc_info()[2])
 
-        call = self._interceptor.intercept_stream_unary(continuation, 
-                                                        client_call_details, 
-                                                        request_iterator) 
+        call = self._interceptor.intercept_stream_unary(continuation,
+                                                        client_call_details,
+                                                        request_iterator)
         return call.result(), call
 
     def with_call(self,
@@ -402,12 +402,12 @@ class _StreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
                   credentials=None,
                   wait_for_ready=None,
                   compression=None):
-        return self._with_call(request_iterator, 
-                               timeout=timeout, 
-                               metadata=metadata, 
-                               credentials=credentials, 
-                               wait_for_ready=wait_for_ready, 
-                               compression=compression) 
+        return self._with_call(request_iterator,
+                               timeout=timeout,
+                               metadata=metadata,
+                               credentials=credentials,
+                               wait_for_ready=wait_for_ready,
+                               compression=compression)
 
     def future(self,
                request_iterator,
@@ -463,12 +463,12 @@ class _StreamStreamMultiCallable(grpc.StreamStreamMultiCallable):
              new_wait_for_ready,
              new_compression) = (_unwrap_client_call_details(
                  new_details, client_call_details))
-            return self._thunk(new_method)(request_iterator, 
-                                           timeout=new_timeout, 
-                                           metadata=new_metadata, 
-                                           credentials=new_credentials, 
-                                           wait_for_ready=new_wait_for_ready, 
-                                           compression=new_compression) 
+            return self._thunk(new_method)(request_iterator,
+                                           timeout=new_timeout,
+                                           metadata=new_metadata,
+                                           credentials=new_credentials,
+                                           wait_for_ready=new_wait_for_ready,
+                                           compression=new_compression)
 
         try:
             return self._interceptor.intercept_stream_stream(
@@ -493,8 +493,8 @@ class _Channel(grpc.Channel):
                     method,
                     request_serializer=None,
                     response_deserializer=None):
-        thunk = lambda m: self._channel.unary_unary(m, request_serializer, 
-                                                    response_deserializer) 
+        thunk = lambda m: self._channel.unary_unary(m, request_serializer,
+                                                    response_deserializer)
         if isinstance(self._interceptor, grpc.UnaryUnaryClientInterceptor):
             return _UnaryUnaryMultiCallable(thunk, method, self._interceptor)
         else:
@@ -504,8 +504,8 @@ class _Channel(grpc.Channel):
                      method,
                      request_serializer=None,
                      response_deserializer=None):
-        thunk = lambda m: self._channel.unary_stream(m, request_serializer, 
-                                                     response_deserializer) 
+        thunk = lambda m: self._channel.unary_stream(m, request_serializer,
+                                                     response_deserializer)
         if isinstance(self._interceptor, grpc.UnaryStreamClientInterceptor):
             return _UnaryStreamMultiCallable(thunk, method, self._interceptor)
         else:
@@ -515,8 +515,8 @@ class _Channel(grpc.Channel):
                      method,
                      request_serializer=None,
                      response_deserializer=None):
-        thunk = lambda m: self._channel.stream_unary(m, request_serializer, 
-                                                     response_deserializer) 
+        thunk = lambda m: self._channel.stream_unary(m, request_serializer,
+                                                     response_deserializer)
         if isinstance(self._interceptor, grpc.StreamUnaryClientInterceptor):
             return _StreamUnaryMultiCallable(thunk, method, self._interceptor)
         else:
@@ -526,8 +526,8 @@ class _Channel(grpc.Channel):
                       method,
                       request_serializer=None,
                       response_deserializer=None):
-        thunk = lambda m: self._channel.stream_stream(m, request_serializer, 
-                                                      response_deserializer) 
+        thunk = lambda m: self._channel.stream_stream(m, request_serializer,
+                                                      response_deserializer)
         if isinstance(self._interceptor, grpc.StreamStreamClientInterceptor):
             return _StreamStreamMultiCallable(thunk, method, self._interceptor)
         else:
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_plugin_wrapping.py b/contrib/libs/grpc/src/python/grpcio/grpc/_plugin_wrapping.py
index e6f86a13d4..e3bfa90916 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_plugin_wrapping.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_plugin_wrapping.py
@@ -70,12 +70,12 @@ class _Plugin(object):
         self._metadata_plugin = metadata_plugin
 
     def __call__(self, service_url, method_name, callback):
-        context = _AuthMetadataContext(_common.decode(service_url), 
-                                       _common.decode(method_name)) 
+        context = _AuthMetadataContext(_common.decode(service_url),
+                                       _common.decode(method_name))
         callback_state = _CallbackState()
         try:
-            self._metadata_plugin( 
-                context, _AuthMetadataPluginCallback(callback_state, callback)) 
+            self._metadata_plugin(
+                context, _AuthMetadataPluginCallback(callback_state, callback))
         except Exception as exception:  # pylint: disable=broad-except
             _LOGGER.exception(
                 'AuthMetadataPluginCallback "%s" raised exception!',
@@ -97,5 +97,5 @@ def metadata_plugin_call_credentials(metadata_plugin, name):
     else:
         effective_name = name
     return grpc.CallCredentials(
-        cygrpc.MetadataPluginCallCredentials(_Plugin(metadata_plugin), 
-                                             _common.encode(effective_name))) 
+        cygrpc.MetadataPluginCallCredentials(_Plugin(metadata_plugin),
+                                             _common.encode(effective_name)))
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_runtime_protos.py b/contrib/libs/grpc/src/python/grpcio/grpc/_runtime_protos.py
index e6cd4bb0f1..7f555ccd9e 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_runtime_protos.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_runtime_protos.py
@@ -1,171 +1,171 @@
-# Copyright 2020 The gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
- 
-import sys 
- 
-_REQUIRED_SYMBOLS = ("_protos", "_services", "_protos_and_services") 
- 
- 
-def _uninstalled_protos(*args, **kwargs): 
-    raise NotImplementedError( 
-        "Install the grpcio-tools package (1.32.0+) to use the protos function." 
-    ) 
- 
- 
-def _uninstalled_services(*args, **kwargs): 
-    raise NotImplementedError( 
-        "Install the grpcio-tools package (1.32.0+) to use the services function." 
-    ) 
- 
- 
-def _uninstalled_protos_and_services(*args, **kwargs): 
-    raise NotImplementedError( 
-        "Install the grpcio-tools package (1.32.0+) to use the protos_and_services function." 
-    ) 
- 
- 
-def _interpreter_version_protos(*args, **kwargs): 
-    raise NotImplementedError( 
-        "The protos function is only on available on Python 3.X interpreters.") 
- 
- 
-def _interpreter_version_services(*args, **kwargs): 
-    raise NotImplementedError( 
-        "The services function is only on available on Python 3.X interpreters." 
-    ) 
- 
- 
-def _interpreter_version_protos_and_services(*args, **kwargs): 
-    raise NotImplementedError( 
-        "The protos_and_services function is only on available on Python 3.X interpreters." 
-    ) 
- 
- 
-def protos(protobuf_path):  # pylint: disable=unused-argument 
-    """Returns a module generated by the indicated .proto file. 
- 
-    THIS IS AN EXPERIMENTAL API. 
- 
-    Use this function to retrieve classes corresponding to message 
-    definitions in the .proto file. 
- 
-    To inspect the contents of the returned module, use the dir function. 
-    For example: 
- 
-    ``` 
-    protos = grpc.protos("foo.proto") 
-    print(dir(protos)) 
-    ``` 
- 
-    The returned module object corresponds to the _pb2.py file generated 
-    by protoc. The path is expected to be relative to an entry on sys.path 
-    and all transitive dependencies of the file should also be resolveable 
-    from an entry on sys.path. 
- 
-    To completely disable the machinery behind this function, set the 
-    GRPC_PYTHON_DISABLE_DYNAMIC_STUBS environment variable to "true". 
- 
-    Args: 
-      protobuf_path: The path to the .proto file on the filesystem. This path 
-        must be resolveable from an entry on sys.path and so must all of its 
-        transitive dependencies. 
- 
-    Returns: 
-      A module object corresponding to the message code for the indicated 
-      .proto file. Equivalent to a generated _pb2.py file. 
-    """ 
- 
- 
-def services(protobuf_path):  # pylint: disable=unused-argument 
-    """Returns a module generated by the indicated .proto file. 
- 
-    THIS IS AN EXPERIMENTAL API. 
- 
-    Use this function to retrieve classes and functions corresponding to 
-    service definitions in the .proto file, including both stub and servicer 
-    definitions. 
- 
-    To inspect the contents of the returned module, use the dir function. 
-    For example: 
- 
-    ``` 
-    services = grpc.services("foo.proto") 
-    print(dir(services)) 
-    ``` 
- 
-    The returned module object corresponds to the _pb2_grpc.py file generated 
-    by protoc. The path is expected to be relative to an entry on sys.path 
-    and all transitive dependencies of the file should also be resolveable 
-    from an entry on sys.path. 
- 
-    To completely disable the machinery behind this function, set the 
-    GRPC_PYTHON_DISABLE_DYNAMIC_STUBS environment variable to "true". 
- 
-    Args: 
-      protobuf_path: The path to the .proto file on the filesystem. This path 
-        must be resolveable from an entry on sys.path and so must all of its 
-        transitive dependencies. 
- 
-    Returns: 
-      A module object corresponding to the stub/service code for the indicated 
-      .proto file. Equivalent to a generated _pb2_grpc.py file. 
-    """ 
- 
- 
-def protos_and_services(protobuf_path):  # pylint: disable=unused-argument 
-    """Returns a 2-tuple of modules corresponding to protos and services. 
- 
-    THIS IS AN EXPERIMENTAL API. 
- 
-    The return value of this function is equivalent to a call to protos and a 
-    call to services. 
- 
-    To completely disable the machinery behind this function, set the 
-    GRPC_PYTHON_DISABLE_DYNAMIC_STUBS environment variable to "true". 
- 
-    Args: 
-      protobuf_path: The path to the .proto file on the filesystem. This path 
-        must be resolveable from an entry on sys.path and so must all of its 
-        transitive dependencies. 
- 
-    Returns: 
-      A 2-tuple of module objects corresponding to (protos(path), services(path)). 
-    """ 
- 
- 
-if sys.version_info < (3, 5, 0): 
-    protos = _interpreter_version_protos 
-    services = _interpreter_version_services 
-    protos_and_services = _interpreter_version_protos_and_services 
-else: 
-    try: 
-        import grpc_tools  # pylint: disable=unused-import 
-    except ImportError as e: 
-        # NOTE: It's possible that we're encountering a transitive ImportError, so 
-        # we check for that and re-raise if so. 
-        if "grpc_tools" not in e.args[0]: 
-            raise 
-        protos = _uninstalled_protos 
-        services = _uninstalled_services 
-        protos_and_services = _uninstalled_protos_and_services 
-    else: 
-        import grpc_tools.protoc  # pylint: disable=unused-import 
-        if all(hasattr(grpc_tools.protoc, sym) for sym in _REQUIRED_SYMBOLS): 
-            from grpc_tools.protoc import _protos as protos  # pylint: disable=unused-import 
-            from grpc_tools.protoc import _services as services  # pylint: disable=unused-import 
-            from grpc_tools.protoc import _protos_and_services as protos_and_services  # pylint: disable=unused-import 
-        else: 
-            protos = _uninstalled_protos 
-            services = _uninstalled_services 
-            protos_and_services = _uninstalled_protos_and_services 
+# Copyright 2020 The gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+
+_REQUIRED_SYMBOLS = ("_protos", "_services", "_protos_and_services")
+
+
+def _uninstalled_protos(*args, **kwargs):
+    raise NotImplementedError(
+        "Install the grpcio-tools package (1.32.0+) to use the protos function."
+    )
+
+
+def _uninstalled_services(*args, **kwargs):
+    raise NotImplementedError(
+        "Install the grpcio-tools package (1.32.0+) to use the services function."
+    )
+
+
+def _uninstalled_protos_and_services(*args, **kwargs):
+    raise NotImplementedError(
+        "Install the grpcio-tools package (1.32.0+) to use the protos_and_services function."
+    )
+
+
+def _interpreter_version_protos(*args, **kwargs):
+    raise NotImplementedError(
+        "The protos function is only on available on Python 3.X interpreters.")
+
+
+def _interpreter_version_services(*args, **kwargs):
+    raise NotImplementedError(
+        "The services function is only on available on Python 3.X interpreters."
+    )
+
+
+def _interpreter_version_protos_and_services(*args, **kwargs):
+    raise NotImplementedError(
+        "The protos_and_services function is only on available on Python 3.X interpreters."
+    )
+
+
+def protos(protobuf_path):  # pylint: disable=unused-argument
+    """Returns a module generated by the indicated .proto file.
+
+    THIS IS AN EXPERIMENTAL API.
+
+    Use this function to retrieve classes corresponding to message
+    definitions in the .proto file.
+
+    To inspect the contents of the returned module, use the dir function.
+    For example:
+
+    ```
+    protos = grpc.protos("foo.proto")
+    print(dir(protos))
+    ```
+
+    The returned module object corresponds to the _pb2.py file generated
+    by protoc. The path is expected to be relative to an entry on sys.path
+    and all transitive dependencies of the file should also be resolveable
+    from an entry on sys.path.
+
+    To completely disable the machinery behind this function, set the
+    GRPC_PYTHON_DISABLE_DYNAMIC_STUBS environment variable to "true".
+
+    Args:
+      protobuf_path: The path to the .proto file on the filesystem. This path
+        must be resolveable from an entry on sys.path and so must all of its
+        transitive dependencies.
+
+    Returns:
+      A module object corresponding to the message code for the indicated
+      .proto file. Equivalent to a generated _pb2.py file.
+    """
+
+
+def services(protobuf_path):  # pylint: disable=unused-argument
+    """Returns a module generated by the indicated .proto file.
+
+    THIS IS AN EXPERIMENTAL API.
+
+    Use this function to retrieve classes and functions corresponding to
+    service definitions in the .proto file, including both stub and servicer
+    definitions.
+
+    To inspect the contents of the returned module, use the dir function.
+    For example:
+
+    ```
+    services = grpc.services("foo.proto")
+    print(dir(services))
+    ```
+
+    The returned module object corresponds to the _pb2_grpc.py file generated
+    by protoc. The path is expected to be relative to an entry on sys.path
+    and all transitive dependencies of the file should also be resolveable
+    from an entry on sys.path.
+
+    To completely disable the machinery behind this function, set the
+    GRPC_PYTHON_DISABLE_DYNAMIC_STUBS environment variable to "true".
+
+    Args:
+      protobuf_path: The path to the .proto file on the filesystem. This path
+        must be resolveable from an entry on sys.path and so must all of its
+        transitive dependencies.
+
+    Returns:
+      A module object corresponding to the stub/service code for the indicated
+      .proto file. Equivalent to a generated _pb2_grpc.py file.
+    """
+
+
+def protos_and_services(protobuf_path):  # pylint: disable=unused-argument
+    """Returns a 2-tuple of modules corresponding to protos and services.
+
+    THIS IS AN EXPERIMENTAL API.
+
+    The return value of this function is equivalent to a call to protos and a
+    call to services.
+
+    To completely disable the machinery behind this function, set the
+    GRPC_PYTHON_DISABLE_DYNAMIC_STUBS environment variable to "true".
+
+    Args:
+      protobuf_path: The path to the .proto file on the filesystem. This path
+        must be resolveable from an entry on sys.path and so must all of its
+        transitive dependencies.
+
+    Returns:
+      A 2-tuple of module objects corresponding to (protos(path), services(path)).
+    """
+
+
+if sys.version_info < (3, 5, 0):
+    protos = _interpreter_version_protos
+    services = _interpreter_version_services
+    protos_and_services = _interpreter_version_protos_and_services
+else:
+    try:
+        import grpc_tools  # pylint: disable=unused-import
+    except ImportError as e:
+        # NOTE: It's possible that we're encountering a transitive ImportError, so
+        # we check for that and re-raise if so.
+        if "grpc_tools" not in e.args[0]:
+            raise
+        protos = _uninstalled_protos
+        services = _uninstalled_services
+        protos_and_services = _uninstalled_protos_and_services
+    else:
+        import grpc_tools.protoc  # pylint: disable=unused-import
+        if all(hasattr(grpc_tools.protoc, sym) for sym in _REQUIRED_SYMBOLS):
+            from grpc_tools.protoc import _protos as protos  # pylint: disable=unused-import
+            from grpc_tools.protoc import _services as services  # pylint: disable=unused-import
+            from grpc_tools.protoc import _protos_and_services as protos_and_services  # pylint: disable=unused-import
+        else:
+            protos = _uninstalled_protos
+            services = _uninstalled_services
+            protos_and_services = _uninstalled_protos_and_services
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_server.py b/contrib/libs/grpc/src/python/grpcio/grpc/_server.py
index acbfb4193f..48ff743995 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_server.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_server.py
@@ -159,10 +159,10 @@ def _abort(state, call, code, details):
         if state.initial_metadata_allowed:
             operations = (
                 _get_initial_metadata_operation(state, None),
-                cygrpc.SendStatusFromServerOperation(state.trailing_metadata, 
-                                                     effective_code, 
-                                                     effective_details, 
-                                                     _EMPTY_FLAGS), 
+                cygrpc.SendStatusFromServerOperation(state.trailing_metadata,
+                                                     effective_code,
+                                                     effective_details,
+                                                     _EMPTY_FLAGS),
             )
             token = _SEND_INITIAL_METADATA_AND_SEND_STATUS_FROM_SERVER_TOKEN
         else:
@@ -278,7 +278,7 @@ class _Context(grpc.ServicerContext):
 
     def auth_context(self):
         return {
-            _common.decode(key): value for key, value in six.iteritems( 
+            _common.decode(key): value for key, value in six.iteritems(
                 cygrpc.auth_context(self._rpc_event.call))
         }
 
@@ -524,9 +524,9 @@ def _status(rpc_event, state, serialized_response):
             code = _completion_code(state)
             details = _details(state)
             operations = [
-                cygrpc.SendStatusFromServerOperation(state.trailing_metadata, 
-                                                     code, details, 
-                                                     _EMPTY_FLAGS), 
+                cygrpc.SendStatusFromServerOperation(state.trailing_metadata,
+                                                     code, details,
+                                                     _EMPTY_FLAGS),
             ]
             if state.initial_metadata_allowed:
                 operations.append(_get_initial_metadata_operation(state, None))
@@ -568,9 +568,9 @@ def _stream_response_in_pool(rpc_event, state, behavior, argument_thunk,
         if response is None:
             _status(rpc_event, state, None)
         else:
-            serialized_response = _serialize_response(rpc_event, state, 
-                                                      response, 
-                                                      response_serializer) 
+            serialized_response = _serialize_response(rpc_event, state,
+                                                      response,
+                                                      response_serializer)
             if serialized_response is not None:
                 _send_response(rpc_event, state, serialized_response)
 
@@ -579,12 +579,12 @@ def _stream_response_in_pool(rpc_event, state, behavior, argument_thunk,
         if argument is not None:
             if hasattr(behavior, 'experimental_non_blocking'
                       ) and behavior.experimental_non_blocking:
-                _call_behavior(rpc_event, 
-                               state, 
-                               behavior, 
-                               argument, 
-                               request_deserializer, 
-                               send_response_callback=send_response) 
+                _call_behavior(rpc_event,
+                               state,
+                               behavior,
+                               argument,
+                               request_deserializer,
+                               send_response_callback=send_response)
             else:
                 response_iterator, proceed = _call_behavior(
                     rpc_event, state, behavior, argument, request_deserializer)
@@ -599,9 +599,9 @@ def _is_rpc_state_active(state):
     return state.client is not _CANCELLED and not state.statused
 
 
-def _send_message_callback_to_blocking_iterator_adapter(rpc_event, state, 
-                                                        send_response_callback, 
-                                                        response_iterator): 
+def _send_message_callback_to_blocking_iterator_adapter(rpc_event, state,
+                                                        send_response_callback,
+                                                        response_iterator):
     while True:
         response, proceed = _take_response_from_response_iterator(
             rpc_event, state, response_iterator)
@@ -648,11 +648,11 @@ def _handle_stream_unary(rpc_event, state, method_handler, default_thread_pool):
                                         method_handler.request_deserializer)
     thread_pool = _select_thread_pool_for_behavior(method_handler.stream_unary,
                                                    default_thread_pool)
-    return thread_pool.submit(_unary_response_in_pool, rpc_event, state, 
-                              method_handler.stream_unary, 
-                              lambda: request_iterator, 
-                              method_handler.request_deserializer, 
-                              method_handler.response_serializer) 
+    return thread_pool.submit(_unary_response_in_pool, rpc_event, state,
+                              method_handler.stream_unary,
+                              lambda: request_iterator,
+                              method_handler.request_deserializer,
+                              method_handler.response_serializer)
 
 
 def _handle_stream_stream(rpc_event, state, method_handler,
@@ -661,11 +661,11 @@ def _handle_stream_stream(rpc_event, state, method_handler,
                                         method_handler.request_deserializer)
     thread_pool = _select_thread_pool_for_behavior(method_handler.stream_stream,
                                                    default_thread_pool)
-    return thread_pool.submit(_stream_response_in_pool, rpc_event, state, 
-                              method_handler.stream_stream, 
-                              lambda: request_iterator, 
-                              method_handler.request_deserializer, 
-                              method_handler.response_serializer) 
+    return thread_pool.submit(_stream_response_in_pool, rpc_event, state,
+                              method_handler.stream_stream,
+                              lambda: request_iterator,
+                              method_handler.request_deserializer,
+                              method_handler.response_serializer)
 
 
 def _find_method_handler(rpc_event, generic_handlers, interceptor_pipeline):
@@ -696,10 +696,10 @@ def _reject_rpc(rpc_event, status, details):
         cygrpc.SendStatusFromServerOperation(None, status, details,
                                              _EMPTY_FLAGS),
     )
-    rpc_event.call.start_server_batch(operations, lambda ignored_event: ( 
-        rpc_state, 
-        (), 
-    )) 
+    rpc_event.call.start_server_batch(operations, lambda ignored_event: (
+        rpc_state,
+        (),
+    ))
     return rpc_state
 
 
@@ -836,10 +836,10 @@ def _process_event_and_continue(state, event):
             concurrency_exceeded = (
                 state.maximum_concurrent_rpcs is not None and
                 state.active_rpc_count >= state.maximum_concurrent_rpcs)
-            rpc_state, rpc_future = _handle_call(event, state.generic_handlers, 
-                                                 state.interceptor_pipeline, 
-                                                 state.thread_pool, 
-                                                 concurrency_exceeded) 
+            rpc_state, rpc_future = _handle_call(event, state.generic_handlers,
+                                                 state.interceptor_pipeline,
+                                                 state.thread_pool,
+                                                 concurrency_exceeded)
             if rpc_state is not None:
                 state.rpc_states.add(rpc_state)
             if rpc_future is not None:
@@ -958,14 +958,14 @@ class _Server(grpc.Server):
         _add_generic_handlers(self._state, generic_rpc_handlers)
 
     def add_insecure_port(self, address):
-        return _common.validate_port_binding_result( 
-            address, _add_insecure_port(self._state, _common.encode(address))) 
+        return _common.validate_port_binding_result(
+            address, _add_insecure_port(self._state, _common.encode(address)))
 
     def add_secure_port(self, address, server_credentials):
-        return _common.validate_port_binding_result( 
-            address, 
-            _add_secure_port(self._state, _common.encode(address), 
-                             server_credentials)) 
+        return _common.validate_port_binding_result(
+            address,
+            _add_secure_port(self._state, _common.encode(address),
+                             server_credentials))
 
     def start(self):
         _start(self._state)
@@ -974,9 +974,9 @@ class _Server(grpc.Server):
         # NOTE(https://bugs.python.org/issue35935)
         # Remove this workaround once threading.Event.wait() is working with
         # CTRL+C across platforms.
-        return _common.wait(self._state.termination_event.wait, 
-                            self._state.termination_event.is_set, 
-                            timeout=timeout) 
+        return _common.wait(self._state.termination_event.wait,
+                            self._state.termination_event.is_set,
+                            timeout=timeout)
 
     def stop(self, grace):
         return _stop(self._state, grace)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/_simple_stubs.py b/contrib/libs/grpc/src/python/grpcio/grpc/_simple_stubs.py
index d884c35a35..baa7ae5dbe 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/_simple_stubs.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/_simple_stubs.py
@@ -1,493 +1,493 @@
-# Copyright 2020 The gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Functions that obviate explicit stubs and explicit channels.""" 
- 
-import collections 
-import datetime 
-import os 
-import logging 
-import threading 
-from typing import (Any, AnyStr, Callable, Dict, Iterator, Optional, Sequence, 
-                    Tuple, TypeVar, Union) 
- 
-import grpc 
-from grpc.experimental import experimental_api 
- 
-RequestType = TypeVar('RequestType') 
-ResponseType = TypeVar('ResponseType') 
- 
-OptionsType = Sequence[Tuple[str, str]] 
-CacheKey = Tuple[str, OptionsType, Optional[grpc.ChannelCredentials], Optional[ 
-    grpc.Compression]] 
- 
-_LOGGER = logging.getLogger(__name__) 
- 
-_EVICTION_PERIOD_KEY = "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" 
-if _EVICTION_PERIOD_KEY in os.environ: 
-    _EVICTION_PERIOD = datetime.timedelta( 
-        seconds=float(os.environ[_EVICTION_PERIOD_KEY])) 
-    _LOGGER.debug("Setting managed channel eviction period to %s", 
-                  _EVICTION_PERIOD) 
-else: 
-    _EVICTION_PERIOD = datetime.timedelta(minutes=10) 
- 
-_MAXIMUM_CHANNELS_KEY = "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" 
-if _MAXIMUM_CHANNELS_KEY in os.environ: 
-    _MAXIMUM_CHANNELS = int(os.environ[_MAXIMUM_CHANNELS_KEY]) 
-    _LOGGER.debug("Setting maximum managed channels to %d", _MAXIMUM_CHANNELS) 
-else: 
-    _MAXIMUM_CHANNELS = 2**8 
- 
-_DEFAULT_TIMEOUT_KEY = "GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS" 
-if _DEFAULT_TIMEOUT_KEY in os.environ: 
-    _DEFAULT_TIMEOUT = float(os.environ[_DEFAULT_TIMEOUT_KEY]) 
-    _LOGGER.debug("Setting default timeout seconds to %f", _DEFAULT_TIMEOUT) 
-else: 
-    _DEFAULT_TIMEOUT = 60.0 
- 
- 
-def _create_channel(target: str, options: Sequence[Tuple[str, str]], 
-                    channel_credentials: Optional[grpc.ChannelCredentials], 
-                    compression: Optional[grpc.Compression]) -> grpc.Channel: 
-    if channel_credentials is grpc.experimental.insecure_channel_credentials(): 
-        _LOGGER.debug(f"Creating insecure channel with options '{options}' " + 
-                      f"and compression '{compression}'") 
-        return grpc.insecure_channel(target, 
-                                     options=options, 
-                                     compression=compression) 
-    else: 
-        _LOGGER.debug( 
-            f"Creating secure channel with credentials '{channel_credentials}', " 
-            + f"options '{options}' and compression '{compression}'") 
-        return grpc.secure_channel(target, 
-                                   credentials=channel_credentials, 
-                                   options=options, 
-                                   compression=compression) 
- 
- 
-class ChannelCache: 
-    # NOTE(rbellevi): Untyped due to reference cycle. 
-    _singleton = None 
-    _lock: threading.RLock = threading.RLock() 
-    _condition: threading.Condition = threading.Condition(lock=_lock) 
-    _eviction_ready: threading.Event = threading.Event() 
- 
-    _mapping: Dict[CacheKey, Tuple[grpc.Channel, datetime.datetime]] 
-    _eviction_thread: threading.Thread 
- 
-    def __init__(self): 
-        self._mapping = collections.OrderedDict() 
-        self._eviction_thread = threading.Thread( 
-            target=ChannelCache._perform_evictions, daemon=True) 
-        self._eviction_thread.start() 
- 
-    @staticmethod 
-    def get(): 
-        with ChannelCache._lock: 
-            if ChannelCache._singleton is None: 
-                ChannelCache._singleton = ChannelCache() 
-        ChannelCache._eviction_ready.wait() 
-        return ChannelCache._singleton 
- 
-    def _evict_locked(self, key: CacheKey): 
-        channel, _ = self._mapping.pop(key) 
-        _LOGGER.debug("Evicting channel %s with configuration %s.", channel, 
-                      key) 
-        channel.close() 
-        del channel 
- 
-    @staticmethod 
-    def _perform_evictions(): 
-        while True: 
-            with ChannelCache._lock: 
-                ChannelCache._eviction_ready.set() 
-                if not ChannelCache._singleton._mapping: 
-                    ChannelCache._condition.wait() 
-                elif len(ChannelCache._singleton._mapping) > _MAXIMUM_CHANNELS: 
-                    key = next(iter(ChannelCache._singleton._mapping.keys())) 
-                    ChannelCache._singleton._evict_locked(key) 
-                    # And immediately reevaluate. 
-                else: 
-                    key, (_, eviction_time) = next( 
-                        iter(ChannelCache._singleton._mapping.items())) 
-                    now = datetime.datetime.now() 
-                    if eviction_time <= now: 
-                        ChannelCache._singleton._evict_locked(key) 
-                        continue 
-                    else: 
-                        time_to_eviction = (eviction_time - now).total_seconds() 
-                        # NOTE: We aim to *eventually* coalesce to a state in 
-                        # which no overdue channels are in the cache and the 
-                        # length of the cache is longer than _MAXIMUM_CHANNELS. 
-                        # We tolerate momentary states in which these two 
-                        # criteria are not met. 
-                        ChannelCache._condition.wait(timeout=time_to_eviction) 
- 
-    def get_channel(self, target: str, options: Sequence[Tuple[str, str]], 
-                    channel_credentials: Optional[grpc.ChannelCredentials], 
-                    insecure: bool, 
-                    compression: Optional[grpc.Compression]) -> grpc.Channel: 
-        if insecure and channel_credentials: 
-            raise ValueError("The insecure option is mutually exclusive with " + 
-                             "the channel_credentials option. Please use one " + 
-                             "or the other.") 
-        if insecure: 
-            channel_credentials = grpc.experimental.insecure_channel_credentials( 
-            ) 
-        elif channel_credentials is None: 
-            _LOGGER.debug("Defaulting to SSL channel credentials.") 
-            channel_credentials = grpc.ssl_channel_credentials() 
-        key = (target, options, channel_credentials, compression) 
-        with self._lock: 
-            channel_data = self._mapping.get(key, None) 
-            if channel_data is not None: 
-                channel = channel_data[0] 
-                self._mapping.pop(key) 
-                self._mapping[key] = (channel, datetime.datetime.now() + 
-                                      _EVICTION_PERIOD) 
-                return channel 
-            else: 
-                channel = _create_channel(target, options, channel_credentials, 
-                                          compression) 
-                self._mapping[key] = (channel, datetime.datetime.now() + 
-                                      _EVICTION_PERIOD) 
-                if len(self._mapping) == 1 or len( 
-                        self._mapping) >= _MAXIMUM_CHANNELS: 
-                    self._condition.notify() 
-                return channel 
- 
-    def _test_only_channel_count(self) -> int: 
-        with self._lock: 
-            return len(self._mapping) 
- 
- 
-@experimental_api 
-def unary_unary( 
-        request: RequestType, 
-        target: str, 
-        method: str, 
-        request_serializer: Optional[Callable[[Any], bytes]] = None, 
-        response_deserializer: Optional[Callable[[bytes], Any]] = None, 
-        options: Sequence[Tuple[AnyStr, AnyStr]] = (), 
-        channel_credentials: Optional[grpc.ChannelCredentials] = None, 
-        insecure: bool = False, 
-        call_credentials: Optional[grpc.CallCredentials] = None, 
-        compression: Optional[grpc.Compression] = None, 
-        wait_for_ready: Optional[bool] = None, 
-        timeout: Optional[float] = _DEFAULT_TIMEOUT, 
-        metadata: Optional[Sequence[Tuple[str, Union[str, bytes]]]] = None 
-) -> ResponseType: 
-    """Invokes a unary-unary RPC without an explicitly specified channel. 
- 
-    THIS IS AN EXPERIMENTAL API. 
- 
-    This is backed by a per-process cache of channels. Channels are evicted 
-    from the cache after a fixed period by a background. Channels will also be 
-    evicted if more than a configured maximum accumulate. 
- 
-    The default eviction period is 10 minutes. One may set the environment 
-    variable "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" to configure this. 
- 
-    The default maximum number of channels is 256. One may set the 
-    environment variable "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" to configure 
-    this. 
- 
-    Args: 
-      request: An iterator that yields request values for the RPC. 
-      target: The server address. 
-      method: The name of the RPC method. 
-      request_serializer: Optional :term:`serializer` for serializing the request 
-        message. Request goes unserialized in case None is passed. 
-      response_deserializer: Optional :term:`deserializer` for deserializing the response 
-        message. Response goes undeserialized in case None is passed. 
-      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core 
-        runtime) to configure the channel. 
-      channel_credentials: A credential applied to the whole channel, e.g. the 
-        return value of grpc.ssl_channel_credentials() or 
-        grpc.insecure_channel_credentials(). 
-      insecure: If True, specifies channel_credentials as 
-        :term:`grpc.insecure_channel_credentials()`. This option is mutually 
-        exclusive with the `channel_credentials` option. 
-      call_credentials: A call credential applied to each call individually, 
-        e.g. the output of grpc.metadata_call_credentials() or 
-        grpc.access_token_call_credentials(). 
-      compression: An optional value indicating the compression method to be 
-        used over the lifetime of the channel, e.g. grpc.Compression.Gzip. 
-      wait_for_ready: An optional flag indicating whether the RPC should fail 
-        immediately if the connection is not ready at the time the RPC is 
-        invoked, or if it should wait until the connection to the server 
-        becomes ready. When using this option, the user will likely also want 
-        to set a timeout. Defaults to True. 
-      timeout: An optional duration of time in seconds to allow for the RPC, 
-        after which an exception will be raised. If timeout is unspecified, 
-        defaults to a timeout controlled by the 
-        GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS environment variable. If that is 
-        unset, defaults to 60 seconds. Supply a value of None to indicate that 
-        no timeout should be enforced. 
-      metadata: Optional metadata to send to the server. 
- 
-    Returns: 
-      The response to the RPC. 
-    """ 
-    channel = ChannelCache.get().get_channel(target, options, 
-                                             channel_credentials, insecure, 
-                                             compression) 
-    multicallable = channel.unary_unary(method, request_serializer, 
-                                        response_deserializer) 
-    wait_for_ready = wait_for_ready if wait_for_ready is not None else True 
-    return multicallable(request, 
-                         metadata=metadata, 
-                         wait_for_ready=wait_for_ready, 
-                         credentials=call_credentials, 
-                         timeout=timeout) 
- 
- 
-@experimental_api 
-def unary_stream( 
-        request: RequestType, 
-        target: str, 
-        method: str, 
-        request_serializer: Optional[Callable[[Any], bytes]] = None, 
-        response_deserializer: Optional[Callable[[bytes], Any]] = None, 
-        options: Sequence[Tuple[AnyStr, AnyStr]] = (), 
-        channel_credentials: Optional[grpc.ChannelCredentials] = None, 
-        insecure: bool = False, 
-        call_credentials: Optional[grpc.CallCredentials] = None, 
-        compression: Optional[grpc.Compression] = None, 
-        wait_for_ready: Optional[bool] = None, 
-        timeout: Optional[float] = _DEFAULT_TIMEOUT, 
-        metadata: Optional[Sequence[Tuple[str, Union[str, bytes]]]] = None 
-) -> Iterator[ResponseType]: 
-    """Invokes a unary-stream RPC without an explicitly specified channel. 
- 
-    THIS IS AN EXPERIMENTAL API. 
- 
-    This is backed by a per-process cache of channels. Channels are evicted 
-    from the cache after a fixed period by a background. Channels will also be 
-    evicted if more than a configured maximum accumulate. 
- 
-    The default eviction period is 10 minutes. One may set the environment 
-    variable "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" to configure this. 
- 
-    The default maximum number of channels is 256. One may set the 
-    environment variable "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" to configure 
-    this. 
- 
-    Args: 
-      request: An iterator that yields request values for the RPC. 
-      target: The server address. 
-      method: The name of the RPC method. 
-      request_serializer: Optional :term:`serializer` for serializing the request 
-        message. Request goes unserialized in case None is passed. 
-      response_deserializer: Optional :term:`deserializer` for deserializing the response 
-        message. Response goes undeserialized in case None is passed. 
-      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core 
-        runtime) to configure the channel. 
-      channel_credentials: A credential applied to the whole channel, e.g. the 
-        return value of grpc.ssl_channel_credentials(). 
-      insecure: If True, specifies channel_credentials as 
-        :term:`grpc.insecure_channel_credentials()`. This option is mutually 
-        exclusive with the `channel_credentials` option. 
-      call_credentials: A call credential applied to each call individually, 
-        e.g. the output of grpc.metadata_call_credentials() or 
-        grpc.access_token_call_credentials(). 
-      compression: An optional value indicating the compression method to be 
-        used over the lifetime of the channel, e.g. grpc.Compression.Gzip. 
-      wait_for_ready: An optional flag indicating whether the RPC should fail 
-        immediately if the connection is not ready at the time the RPC is 
-        invoked, or if it should wait until the connection to the server 
-        becomes ready. When using this option, the user will likely also want 
-        to set a timeout. Defaults to True. 
-      timeout: An optional duration of time in seconds to allow for the RPC, 
-        after which an exception will be raised. If timeout is unspecified, 
-        defaults to a timeout controlled by the 
-        GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS environment variable. If that is 
-        unset, defaults to 60 seconds. Supply a value of None to indicate that 
-        no timeout should be enforced. 
-      metadata: Optional metadata to send to the server. 
- 
-    Returns: 
-      An iterator of responses. 
-    """ 
-    channel = ChannelCache.get().get_channel(target, options, 
-                                             channel_credentials, insecure, 
-                                             compression) 
-    multicallable = channel.unary_stream(method, request_serializer, 
-                                         response_deserializer) 
-    wait_for_ready = wait_for_ready if wait_for_ready is not None else True 
-    return multicallable(request, 
-                         metadata=metadata, 
-                         wait_for_ready=wait_for_ready, 
-                         credentials=call_credentials, 
-                         timeout=timeout) 
- 
- 
-@experimental_api 
-def stream_unary( 
-        request_iterator: Iterator[RequestType], 
-        target: str, 
-        method: str, 
-        request_serializer: Optional[Callable[[Any], bytes]] = None, 
-        response_deserializer: Optional[Callable[[bytes], Any]] = None, 
-        options: Sequence[Tuple[AnyStr, AnyStr]] = (), 
-        channel_credentials: Optional[grpc.ChannelCredentials] = None, 
-        insecure: bool = False, 
-        call_credentials: Optional[grpc.CallCredentials] = None, 
-        compression: Optional[grpc.Compression] = None, 
-        wait_for_ready: Optional[bool] = None, 
-        timeout: Optional[float] = _DEFAULT_TIMEOUT, 
-        metadata: Optional[Sequence[Tuple[str, Union[str, bytes]]]] = None 
-) -> ResponseType: 
-    """Invokes a stream-unary RPC without an explicitly specified channel. 
- 
-    THIS IS AN EXPERIMENTAL API. 
- 
-    This is backed by a per-process cache of channels. Channels are evicted 
-    from the cache after a fixed period by a background. Channels will also be 
-    evicted if more than a configured maximum accumulate. 
- 
-    The default eviction period is 10 minutes. One may set the environment 
-    variable "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" to configure this. 
- 
-    The default maximum number of channels is 256. One may set the 
-    environment variable "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" to configure 
-    this. 
- 
-    Args: 
-      request_iterator: An iterator that yields request values for the RPC. 
-      target: The server address. 
-      method: The name of the RPC method. 
-      request_serializer: Optional :term:`serializer` for serializing the request 
-        message. Request goes unserialized in case None is passed. 
-      response_deserializer: Optional :term:`deserializer` for deserializing the response 
-        message. Response goes undeserialized in case None is passed. 
-      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core 
-        runtime) to configure the channel. 
-      channel_credentials: A credential applied to the whole channel, e.g. the 
-        return value of grpc.ssl_channel_credentials(). 
-      call_credentials: A call credential applied to each call individually, 
-        e.g. the output of grpc.metadata_call_credentials() or 
-        grpc.access_token_call_credentials(). 
-      insecure: If True, specifies channel_credentials as 
-        :term:`grpc.insecure_channel_credentials()`. This option is mutually 
-        exclusive with the `channel_credentials` option. 
-      compression: An optional value indicating the compression method to be 
-        used over the lifetime of the channel, e.g. grpc.Compression.Gzip. 
-      wait_for_ready: An optional flag indicating whether the RPC should fail 
-        immediately if the connection is not ready at the time the RPC is 
-        invoked, or if it should wait until the connection to the server 
-        becomes ready. When using this option, the user will likely also want 
-        to set a timeout. Defaults to True. 
-      timeout: An optional duration of time in seconds to allow for the RPC, 
-        after which an exception will be raised. If timeout is unspecified, 
-        defaults to a timeout controlled by the 
-        GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS environment variable. If that is 
-        unset, defaults to 60 seconds. Supply a value of None to indicate that 
-        no timeout should be enforced. 
-      metadata: Optional metadata to send to the server. 
- 
-    Returns: 
-      The response to the RPC. 
-    """ 
-    channel = ChannelCache.get().get_channel(target, options, 
-                                             channel_credentials, insecure, 
-                                             compression) 
-    multicallable = channel.stream_unary(method, request_serializer, 
-                                         response_deserializer) 
-    wait_for_ready = wait_for_ready if wait_for_ready is not None else True 
-    return multicallable(request_iterator, 
-                         metadata=metadata, 
-                         wait_for_ready=wait_for_ready, 
-                         credentials=call_credentials, 
-                         timeout=timeout) 
- 
- 
-@experimental_api 
-def stream_stream( 
-        request_iterator: Iterator[RequestType], 
-        target: str, 
-        method: str, 
-        request_serializer: Optional[Callable[[Any], bytes]] = None, 
-        response_deserializer: Optional[Callable[[bytes], Any]] = None, 
-        options: Sequence[Tuple[AnyStr, AnyStr]] = (), 
-        channel_credentials: Optional[grpc.ChannelCredentials] = None, 
-        insecure: bool = False, 
-        call_credentials: Optional[grpc.CallCredentials] = None, 
-        compression: Optional[grpc.Compression] = None, 
-        wait_for_ready: Optional[bool] = None, 
-        timeout: Optional[float] = _DEFAULT_TIMEOUT, 
-        metadata: Optional[Sequence[Tuple[str, Union[str, bytes]]]] = None 
-) -> Iterator[ResponseType]: 
-    """Invokes a stream-stream RPC without an explicitly specified channel. 
- 
-    THIS IS AN EXPERIMENTAL API. 
- 
-    This is backed by a per-process cache of channels. Channels are evicted 
-    from the cache after a fixed period by a background. Channels will also be 
-    evicted if more than a configured maximum accumulate. 
- 
-    The default eviction period is 10 minutes. One may set the environment 
-    variable "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" to configure this. 
- 
-    The default maximum number of channels is 256. One may set the 
-    environment variable "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" to configure 
-    this. 
- 
-    Args: 
-      request_iterator: An iterator that yields request values for the RPC. 
-      target: The server address. 
-      method: The name of the RPC method. 
-      request_serializer: Optional :term:`serializer` for serializing the request 
-        message. Request goes unserialized in case None is passed. 
-      response_deserializer: Optional :term:`deserializer` for deserializing the response 
-        message. Response goes undeserialized in case None is passed. 
-      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core 
-        runtime) to configure the channel. 
-      channel_credentials: A credential applied to the whole channel, e.g. the 
-        return value of grpc.ssl_channel_credentials(). 
-      call_credentials: A call credential applied to each call individually, 
-        e.g. the output of grpc.metadata_call_credentials() or 
-        grpc.access_token_call_credentials(). 
-      insecure: If True, specifies channel_credentials as 
-        :term:`grpc.insecure_channel_credentials()`. This option is mutually 
-        exclusive with the `channel_credentials` option. 
-      compression: An optional value indicating the compression method to be 
-        used over the lifetime of the channel, e.g. grpc.Compression.Gzip. 
-      wait_for_ready: An optional flag indicating whether the RPC should fail 
-        immediately if the connection is not ready at the time the RPC is 
-        invoked, or if it should wait until the connection to the server 
-        becomes ready. When using this option, the user will likely also want 
-        to set a timeout. Defaults to True. 
-      timeout: An optional duration of time in seconds to allow for the RPC, 
-        after which an exception will be raised. If timeout is unspecified, 
-        defaults to a timeout controlled by the 
-        GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS environment variable. If that is 
-        unset, defaults to 60 seconds. Supply a value of None to indicate that 
-        no timeout should be enforced. 
-      metadata: Optional metadata to send to the server. 
- 
-    Returns: 
-      An iterator of responses. 
-    """ 
-    channel = ChannelCache.get().get_channel(target, options, 
-                                             channel_credentials, insecure, 
-                                             compression) 
-    multicallable = channel.stream_stream(method, request_serializer, 
-                                          response_deserializer) 
-    wait_for_ready = wait_for_ready if wait_for_ready is not None else True 
-    return multicallable(request_iterator, 
-                         metadata=metadata, 
-                         wait_for_ready=wait_for_ready, 
-                         credentials=call_credentials, 
-                         timeout=timeout) 
+# Copyright 2020 The gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Functions that obviate explicit stubs and explicit channels."""
+
+import collections
+import datetime
+import os
+import logging
+import threading
+from typing import (Any, AnyStr, Callable, Dict, Iterator, Optional, Sequence,
+                    Tuple, TypeVar, Union)
+
+import grpc
+from grpc.experimental import experimental_api
+
+RequestType = TypeVar('RequestType')
+ResponseType = TypeVar('ResponseType')
+
+OptionsType = Sequence[Tuple[str, str]]
+CacheKey = Tuple[str, OptionsType, Optional[grpc.ChannelCredentials], Optional[
+    grpc.Compression]]
+
+_LOGGER = logging.getLogger(__name__)
+
+_EVICTION_PERIOD_KEY = "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS"
+if _EVICTION_PERIOD_KEY in os.environ:
+    _EVICTION_PERIOD = datetime.timedelta(
+        seconds=float(os.environ[_EVICTION_PERIOD_KEY]))
+    _LOGGER.debug("Setting managed channel eviction period to %s",
+                  _EVICTION_PERIOD)
+else:
+    _EVICTION_PERIOD = datetime.timedelta(minutes=10)
+
+_MAXIMUM_CHANNELS_KEY = "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM"
+if _MAXIMUM_CHANNELS_KEY in os.environ:
+    _MAXIMUM_CHANNELS = int(os.environ[_MAXIMUM_CHANNELS_KEY])
+    _LOGGER.debug("Setting maximum managed channels to %d", _MAXIMUM_CHANNELS)
+else:
+    _MAXIMUM_CHANNELS = 2**8
+
+_DEFAULT_TIMEOUT_KEY = "GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS"
+if _DEFAULT_TIMEOUT_KEY in os.environ:
+    _DEFAULT_TIMEOUT = float(os.environ[_DEFAULT_TIMEOUT_KEY])
+    _LOGGER.debug("Setting default timeout seconds to %f", _DEFAULT_TIMEOUT)
+else:
+    _DEFAULT_TIMEOUT = 60.0
+
+
+def _create_channel(target: str, options: Sequence[Tuple[str, str]],
+                    channel_credentials: Optional[grpc.ChannelCredentials],
+                    compression: Optional[grpc.Compression]) -> grpc.Channel:
+    if channel_credentials is grpc.experimental.insecure_channel_credentials():
+        _LOGGER.debug(f"Creating insecure channel with options '{options}' " +
+                      f"and compression '{compression}'")
+        return grpc.insecure_channel(target,
+                                     options=options,
+                                     compression=compression)
+    else:
+        _LOGGER.debug(
+            f"Creating secure channel with credentials '{channel_credentials}', "
+            + f"options '{options}' and compression '{compression}'")
+        return grpc.secure_channel(target,
+                                   credentials=channel_credentials,
+                                   options=options,
+                                   compression=compression)
+
+
+class ChannelCache:
+    # NOTE(rbellevi): Untyped due to reference cycle.
+    _singleton = None
+    _lock: threading.RLock = threading.RLock()
+    _condition: threading.Condition = threading.Condition(lock=_lock)
+    _eviction_ready: threading.Event = threading.Event()
+
+    _mapping: Dict[CacheKey, Tuple[grpc.Channel, datetime.datetime]]
+    _eviction_thread: threading.Thread
+
+    def __init__(self):
+        self._mapping = collections.OrderedDict()
+        self._eviction_thread = threading.Thread(
+            target=ChannelCache._perform_evictions, daemon=True)
+        self._eviction_thread.start()
+
+    @staticmethod
+    def get():
+        with ChannelCache._lock:
+            if ChannelCache._singleton is None:
+                ChannelCache._singleton = ChannelCache()
+        ChannelCache._eviction_ready.wait()
+        return ChannelCache._singleton
+
+    def _evict_locked(self, key: CacheKey):
+        channel, _ = self._mapping.pop(key)
+        _LOGGER.debug("Evicting channel %s with configuration %s.", channel,
+                      key)
+        channel.close()
+        del channel
+
+    @staticmethod
+    def _perform_evictions():
+        while True:
+            with ChannelCache._lock:
+                ChannelCache._eviction_ready.set()
+                if not ChannelCache._singleton._mapping:
+                    ChannelCache._condition.wait()
+                elif len(ChannelCache._singleton._mapping) > _MAXIMUM_CHANNELS:
+                    key = next(iter(ChannelCache._singleton._mapping.keys()))
+                    ChannelCache._singleton._evict_locked(key)
+                    # And immediately reevaluate.
+                else:
+                    key, (_, eviction_time) = next(
+                        iter(ChannelCache._singleton._mapping.items()))
+                    now = datetime.datetime.now()
+                    if eviction_time <= now:
+                        ChannelCache._singleton._evict_locked(key)
+                        continue
+                    else:
+                        time_to_eviction = (eviction_time - now).total_seconds()
+                        # NOTE: We aim to *eventually* coalesce to a state in
+                        # which no overdue channels are in the cache and the
+                        # length of the cache is longer than _MAXIMUM_CHANNELS.
+                        # We tolerate momentary states in which these two
+                        # criteria are not met.
+                        ChannelCache._condition.wait(timeout=time_to_eviction)
+
+    def get_channel(self, target: str, options: Sequence[Tuple[str, str]],
+                    channel_credentials: Optional[grpc.ChannelCredentials],
+                    insecure: bool,
+                    compression: Optional[grpc.Compression]) -> grpc.Channel:
+        if insecure and channel_credentials:
+            raise ValueError("The insecure option is mutually exclusive with " +
+                             "the channel_credentials option. Please use one " +
+                             "or the other.")
+        if insecure:
+            channel_credentials = grpc.experimental.insecure_channel_credentials(
+            )
+        elif channel_credentials is None:
+            _LOGGER.debug("Defaulting to SSL channel credentials.")
+            channel_credentials = grpc.ssl_channel_credentials()
+        key = (target, options, channel_credentials, compression)
+        with self._lock:
+            channel_data = self._mapping.get(key, None)
+            if channel_data is not None:
+                channel = channel_data[0]
+                self._mapping.pop(key)
+                self._mapping[key] = (channel, datetime.datetime.now() +
+                                      _EVICTION_PERIOD)
+                return channel
+            else:
+                channel = _create_channel(target, options, channel_credentials,
+                                          compression)
+                self._mapping[key] = (channel, datetime.datetime.now() +
+                                      _EVICTION_PERIOD)
+                if len(self._mapping) == 1 or len(
+                        self._mapping) >= _MAXIMUM_CHANNELS:
+                    self._condition.notify()
+                return channel
+
+    def _test_only_channel_count(self) -> int:
+        with self._lock:
+            return len(self._mapping)
+
+
+@experimental_api
+def unary_unary(
+        request: RequestType,
+        target: str,
+        method: str,
+        request_serializer: Optional[Callable[[Any], bytes]] = None,
+        response_deserializer: Optional[Callable[[bytes], Any]] = None,
+        options: Sequence[Tuple[AnyStr, AnyStr]] = (),
+        channel_credentials: Optional[grpc.ChannelCredentials] = None,
+        insecure: bool = False,
+        call_credentials: Optional[grpc.CallCredentials] = None,
+        compression: Optional[grpc.Compression] = None,
+        wait_for_ready: Optional[bool] = None,
+        timeout: Optional[float] = _DEFAULT_TIMEOUT,
+        metadata: Optional[Sequence[Tuple[str, Union[str, bytes]]]] = None
+) -> ResponseType:
+    """Invokes a unary-unary RPC without an explicitly specified channel.
+
+    THIS IS AN EXPERIMENTAL API.
+
+    This is backed by a per-process cache of channels. Channels are evicted
+    from the cache after a fixed period by a background. Channels will also be
+    evicted if more than a configured maximum accumulate.
+
+    The default eviction period is 10 minutes. One may set the environment
+    variable "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" to configure this.
+
+    The default maximum number of channels is 256. One may set the
+    environment variable "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" to configure
+    this.
+
+    Args:
+      request: An iterator that yields request values for the RPC.
+      target: The server address.
+      method: The name of the RPC method.
+      request_serializer: Optional :term:`serializer` for serializing the request
+        message. Request goes unserialized in case None is passed.
+      response_deserializer: Optional :term:`deserializer` for deserializing the response
+        message. Response goes undeserialized in case None is passed.
+      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core
+        runtime) to configure the channel.
+      channel_credentials: A credential applied to the whole channel, e.g. the
+        return value of grpc.ssl_channel_credentials() or
+        grpc.insecure_channel_credentials().
+      insecure: If True, specifies channel_credentials as
+        :term:`grpc.insecure_channel_credentials()`. This option is mutually
+        exclusive with the `channel_credentials` option.
+      call_credentials: A call credential applied to each call individually,
+        e.g. the output of grpc.metadata_call_credentials() or
+        grpc.access_token_call_credentials().
+      compression: An optional value indicating the compression method to be
+        used over the lifetime of the channel, e.g. grpc.Compression.Gzip.
+      wait_for_ready: An optional flag indicating whether the RPC should fail
+        immediately if the connection is not ready at the time the RPC is
+        invoked, or if it should wait until the connection to the server
+        becomes ready. When using this option, the user will likely also want
+        to set a timeout. Defaults to True.
+      timeout: An optional duration of time in seconds to allow for the RPC,
+        after which an exception will be raised. If timeout is unspecified,
+        defaults to a timeout controlled by the
+        GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS environment variable. If that is
+        unset, defaults to 60 seconds. Supply a value of None to indicate that
+        no timeout should be enforced.
+      metadata: Optional metadata to send to the server.
+
+    Returns:
+      The response to the RPC.
+    """
+    channel = ChannelCache.get().get_channel(target, options,
+                                             channel_credentials, insecure,
+                                             compression)
+    multicallable = channel.unary_unary(method, request_serializer,
+                                        response_deserializer)
+    wait_for_ready = wait_for_ready if wait_for_ready is not None else True
+    return multicallable(request,
+                         metadata=metadata,
+                         wait_for_ready=wait_for_ready,
+                         credentials=call_credentials,
+                         timeout=timeout)
+
+
+@experimental_api
+def unary_stream(
+        request: RequestType,
+        target: str,
+        method: str,
+        request_serializer: Optional[Callable[[Any], bytes]] = None,
+        response_deserializer: Optional[Callable[[bytes], Any]] = None,
+        options: Sequence[Tuple[AnyStr, AnyStr]] = (),
+        channel_credentials: Optional[grpc.ChannelCredentials] = None,
+        insecure: bool = False,
+        call_credentials: Optional[grpc.CallCredentials] = None,
+        compression: Optional[grpc.Compression] = None,
+        wait_for_ready: Optional[bool] = None,
+        timeout: Optional[float] = _DEFAULT_TIMEOUT,
+        metadata: Optional[Sequence[Tuple[str, Union[str, bytes]]]] = None
+) -> Iterator[ResponseType]:
+    """Invokes a unary-stream RPC without an explicitly specified channel.
+
+    THIS IS AN EXPERIMENTAL API.
+
+    This is backed by a per-process cache of channels. Channels are evicted
+    from the cache after a fixed period by a background. Channels will also be
+    evicted if more than a configured maximum accumulate.
+
+    The default eviction period is 10 minutes. One may set the environment
+    variable "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" to configure this.
+
+    The default maximum number of channels is 256. One may set the
+    environment variable "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" to configure
+    this.
+
+    Args:
+      request: An iterator that yields request values for the RPC.
+      target: The server address.
+      method: The name of the RPC method.
+      request_serializer: Optional :term:`serializer` for serializing the request
+        message. Request goes unserialized in case None is passed.
+      response_deserializer: Optional :term:`deserializer` for deserializing the response
+        message. Response goes undeserialized in case None is passed.
+      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core
+        runtime) to configure the channel.
+      channel_credentials: A credential applied to the whole channel, e.g. the
+        return value of grpc.ssl_channel_credentials().
+      insecure: If True, specifies channel_credentials as
+        :term:`grpc.insecure_channel_credentials()`. This option is mutually
+        exclusive with the `channel_credentials` option.
+      call_credentials: A call credential applied to each call individually,
+        e.g. the output of grpc.metadata_call_credentials() or
+        grpc.access_token_call_credentials().
+      compression: An optional value indicating the compression method to be
+        used over the lifetime of the channel, e.g. grpc.Compression.Gzip.
+      wait_for_ready: An optional flag indicating whether the RPC should fail
+        immediately if the connection is not ready at the time the RPC is
+        invoked, or if it should wait until the connection to the server
+        becomes ready. When using this option, the user will likely also want
+        to set a timeout. Defaults to True.
+      timeout: An optional duration of time in seconds to allow for the RPC,
+        after which an exception will be raised. If timeout is unspecified,
+        defaults to a timeout controlled by the
+        GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS environment variable. If that is
+        unset, defaults to 60 seconds. Supply a value of None to indicate that
+        no timeout should be enforced.
+      metadata: Optional metadata to send to the server.
+
+    Returns:
+      An iterator of responses.
+    """
+    channel = ChannelCache.get().get_channel(target, options,
+                                             channel_credentials, insecure,
+                                             compression)
+    multicallable = channel.unary_stream(method, request_serializer,
+                                         response_deserializer)
+    wait_for_ready = wait_for_ready if wait_for_ready is not None else True
+    return multicallable(request,
+                         metadata=metadata,
+                         wait_for_ready=wait_for_ready,
+                         credentials=call_credentials,
+                         timeout=timeout)
+
+
+@experimental_api
+def stream_unary(
+        request_iterator: Iterator[RequestType],
+        target: str,
+        method: str,
+        request_serializer: Optional[Callable[[Any], bytes]] = None,
+        response_deserializer: Optional[Callable[[bytes], Any]] = None,
+        options: Sequence[Tuple[AnyStr, AnyStr]] = (),
+        channel_credentials: Optional[grpc.ChannelCredentials] = None,
+        insecure: bool = False,
+        call_credentials: Optional[grpc.CallCredentials] = None,
+        compression: Optional[grpc.Compression] = None,
+        wait_for_ready: Optional[bool] = None,
+        timeout: Optional[float] = _DEFAULT_TIMEOUT,
+        metadata: Optional[Sequence[Tuple[str, Union[str, bytes]]]] = None
+) -> ResponseType:
+    """Invokes a stream-unary RPC without an explicitly specified channel.
+
+    THIS IS AN EXPERIMENTAL API.
+
+    This is backed by a per-process cache of channels. Channels are evicted
+    from the cache after a fixed period by a background. Channels will also be
+    evicted if more than a configured maximum accumulate.
+
+    The default eviction period is 10 minutes. One may set the environment
+    variable "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" to configure this.
+
+    The default maximum number of channels is 256. One may set the
+    environment variable "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" to configure
+    this.
+
+    Args:
+      request_iterator: An iterator that yields request values for the RPC.
+      target: The server address.
+      method: The name of the RPC method.
+      request_serializer: Optional :term:`serializer` for serializing the request
+        message. Request goes unserialized in case None is passed.
+      response_deserializer: Optional :term:`deserializer` for deserializing the response
+        message. Response goes undeserialized in case None is passed.
+      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core
+        runtime) to configure the channel.
+      channel_credentials: A credential applied to the whole channel, e.g. the
+        return value of grpc.ssl_channel_credentials().
+      call_credentials: A call credential applied to each call individually,
+        e.g. the output of grpc.metadata_call_credentials() or
+        grpc.access_token_call_credentials().
+      insecure: If True, specifies channel_credentials as
+        :term:`grpc.insecure_channel_credentials()`. This option is mutually
+        exclusive with the `channel_credentials` option.
+      compression: An optional value indicating the compression method to be
+        used over the lifetime of the channel, e.g. grpc.Compression.Gzip.
+      wait_for_ready: An optional flag indicating whether the RPC should fail
+        immediately if the connection is not ready at the time the RPC is
+        invoked, or if it should wait until the connection to the server
+        becomes ready. When using this option, the user will likely also want
+        to set a timeout. Defaults to True.
+      timeout: An optional duration of time in seconds to allow for the RPC,
+        after which an exception will be raised. If timeout is unspecified,
+        defaults to a timeout controlled by the
+        GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS environment variable. If that is
+        unset, defaults to 60 seconds. Supply a value of None to indicate that
+        no timeout should be enforced.
+      metadata: Optional metadata to send to the server.
+
+    Returns:
+      The response to the RPC.
+    """
+    channel = ChannelCache.get().get_channel(target, options,
+                                             channel_credentials, insecure,
+                                             compression)
+    multicallable = channel.stream_unary(method, request_serializer,
+                                         response_deserializer)
+    wait_for_ready = wait_for_ready if wait_for_ready is not None else True
+    return multicallable(request_iterator,
+                         metadata=metadata,
+                         wait_for_ready=wait_for_ready,
+                         credentials=call_credentials,
+                         timeout=timeout)
+
+
+@experimental_api
+def stream_stream(
+        request_iterator: Iterator[RequestType],
+        target: str,
+        method: str,
+        request_serializer: Optional[Callable[[Any], bytes]] = None,
+        response_deserializer: Optional[Callable[[bytes], Any]] = None,
+        options: Sequence[Tuple[AnyStr, AnyStr]] = (),
+        channel_credentials: Optional[grpc.ChannelCredentials] = None,
+        insecure: bool = False,
+        call_credentials: Optional[grpc.CallCredentials] = None,
+        compression: Optional[grpc.Compression] = None,
+        wait_for_ready: Optional[bool] = None,
+        timeout: Optional[float] = _DEFAULT_TIMEOUT,
+        metadata: Optional[Sequence[Tuple[str, Union[str, bytes]]]] = None
+) -> Iterator[ResponseType]:
+    """Invokes a stream-stream RPC without an explicitly specified channel.
+
+    THIS IS AN EXPERIMENTAL API.
+
+    This is backed by a per-process cache of channels. Channels are evicted
+    from the cache after a fixed period by a background. Channels will also be
+    evicted if more than a configured maximum accumulate.
+
+    The default eviction period is 10 minutes. One may set the environment
+    variable "GRPC_PYTHON_MANAGED_CHANNEL_EVICTION_SECONDS" to configure this.
+
+    The default maximum number of channels is 256. One may set the
+    environment variable "GRPC_PYTHON_MANAGED_CHANNEL_MAXIMUM" to configure
+    this.
+
+    Args:
+      request_iterator: An iterator that yields request values for the RPC.
+      target: The server address.
+      method: The name of the RPC method.
+      request_serializer: Optional :term:`serializer` for serializing the request
+        message. Request goes unserialized in case None is passed.
+      response_deserializer: Optional :term:`deserializer` for deserializing the response
+        message. Response goes undeserialized in case None is passed.
+      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC Core
+        runtime) to configure the channel.
+      channel_credentials: A credential applied to the whole channel, e.g. the
+        return value of grpc.ssl_channel_credentials().
+      call_credentials: A call credential applied to each call individually,
+        e.g. the output of grpc.metadata_call_credentials() or
+        grpc.access_token_call_credentials().
+      insecure: If True, specifies channel_credentials as
+        :term:`grpc.insecure_channel_credentials()`. This option is mutually
+        exclusive with the `channel_credentials` option.
+      compression: An optional value indicating the compression method to be
+        used over the lifetime of the channel, e.g. grpc.Compression.Gzip.
+      wait_for_ready: An optional flag indicating whether the RPC should fail
+        immediately if the connection is not ready at the time the RPC is
+        invoked, or if it should wait until the connection to the server
+        becomes ready. When using this option, the user will likely also want
+        to set a timeout. Defaults to True.
+      timeout: An optional duration of time in seconds to allow for the RPC,
+        after which an exception will be raised. If timeout is unspecified,
+        defaults to a timeout controlled by the
+        GRPC_PYTHON_DEFAULT_TIMEOUT_SECONDS environment variable. If that is
+        unset, defaults to 60 seconds. Supply a value of None to indicate that
+        no timeout should be enforced.
+      metadata: Optional metadata to send to the server.
+
+    Returns:
+      An iterator of responses.
+    """
+    channel = ChannelCache.get().get_channel(target, options,
+                                             channel_credentials, insecure,
+                                             compression)
+    multicallable = channel.stream_stream(method, request_serializer,
+                                          response_deserializer)
+    wait_for_ready = wait_for_ready if wait_for_ready is not None else True
+    return multicallable(request_iterator,
+                         metadata=metadata,
+                         wait_for_ready=wait_for_ready,
+                         credentials=call_credentials,
+                         timeout=timeout)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/__init__.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/__init__.py
index a947e69407..2933aa5a45 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/__init__.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/__init__.py
@@ -1,81 +1,81 @@
-# Copyright 2019 gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""gRPC's Asynchronous Python API. 
- 
-gRPC Async API objects may only be used on the thread on which they were 
-created. AsyncIO doesn't provide thread safety for most of its APIs. 
-""" 
- 
-from typing import Any, Optional, Sequence, Tuple 
- 
-import grpc 
-from grpc._cython.cygrpc import (init_grpc_aio, shutdown_grpc_aio, EOF, 
-                                 AbortError, BaseError, InternalError, 
-                                 UsageError) 
- 
-from ._base_call import (Call, RpcContext, StreamStreamCall, StreamUnaryCall, 
-                         UnaryStreamCall, UnaryUnaryCall) 
-from ._base_channel import (Channel, StreamStreamMultiCallable, 
-                            StreamUnaryMultiCallable, UnaryStreamMultiCallable, 
-                            UnaryUnaryMultiCallable) 
-from ._call import AioRpcError 
-from ._interceptor import (ClientCallDetails, ClientInterceptor, 
-                           InterceptedUnaryUnaryCall, 
-                           UnaryUnaryClientInterceptor, 
-                           UnaryStreamClientInterceptor, 
-                           StreamUnaryClientInterceptor, 
-                           StreamStreamClientInterceptor, ServerInterceptor) 
-from ._server import server 
-from ._base_server import Server, ServicerContext 
-from ._typing import ChannelArgumentType 
-from ._channel import insecure_channel, secure_channel 
-from ._metadata import Metadata 
- 
-###################################  __all__  ################################# 
- 
-__all__ = ( 
-    'init_grpc_aio', 
-    'shutdown_grpc_aio', 
-    'AioRpcError', 
-    'RpcContext', 
-    'Call', 
-    'UnaryUnaryCall', 
-    'UnaryStreamCall', 
-    'StreamUnaryCall', 
-    'StreamStreamCall', 
-    'Channel', 
-    'UnaryUnaryMultiCallable', 
-    'UnaryStreamMultiCallable', 
-    'StreamUnaryMultiCallable', 
-    'StreamStreamMultiCallable', 
-    'ClientCallDetails', 
-    'ClientInterceptor', 
-    'UnaryStreamClientInterceptor', 
-    'UnaryUnaryClientInterceptor', 
-    'StreamUnaryClientInterceptor', 
-    'StreamStreamClientInterceptor', 
-    'InterceptedUnaryUnaryCall', 
-    'ServerInterceptor', 
-    'insecure_channel', 
-    'server', 
-    'Server', 
-    'ServicerContext', 
-    'EOF', 
-    'secure_channel', 
-    'AbortError', 
-    'BaseError', 
-    'UsageError', 
-    'InternalError', 
-    'Metadata', 
-) 
+# Copyright 2019 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""gRPC's Asynchronous Python API.
+
+gRPC Async API objects may only be used on the thread on which they were
+created. AsyncIO doesn't provide thread safety for most of its APIs.
+"""
+
+from typing import Any, Optional, Sequence, Tuple
+
+import grpc
+from grpc._cython.cygrpc import (init_grpc_aio, shutdown_grpc_aio, EOF,
+                                 AbortError, BaseError, InternalError,
+                                 UsageError)
+
+from ._base_call import (Call, RpcContext, StreamStreamCall, StreamUnaryCall,
+                         UnaryStreamCall, UnaryUnaryCall)
+from ._base_channel import (Channel, StreamStreamMultiCallable,
+                            StreamUnaryMultiCallable, UnaryStreamMultiCallable,
+                            UnaryUnaryMultiCallable)
+from ._call import AioRpcError
+from ._interceptor import (ClientCallDetails, ClientInterceptor,
+                           InterceptedUnaryUnaryCall,
+                           UnaryUnaryClientInterceptor,
+                           UnaryStreamClientInterceptor,
+                           StreamUnaryClientInterceptor,
+                           StreamStreamClientInterceptor, ServerInterceptor)
+from ._server import server
+from ._base_server import Server, ServicerContext
+from ._typing import ChannelArgumentType
+from ._channel import insecure_channel, secure_channel
+from ._metadata import Metadata
+
+###################################  __all__  #################################
+
+__all__ = (
+    'init_grpc_aio',
+    'shutdown_grpc_aio',
+    'AioRpcError',
+    'RpcContext',
+    'Call',
+    'UnaryUnaryCall',
+    'UnaryStreamCall',
+    'StreamUnaryCall',
+    'StreamStreamCall',
+    'Channel',
+    'UnaryUnaryMultiCallable',
+    'UnaryStreamMultiCallable',
+    'StreamUnaryMultiCallable',
+    'StreamStreamMultiCallable',
+    'ClientCallDetails',
+    'ClientInterceptor',
+    'UnaryStreamClientInterceptor',
+    'UnaryUnaryClientInterceptor',
+    'StreamUnaryClientInterceptor',
+    'StreamStreamClientInterceptor',
+    'InterceptedUnaryUnaryCall',
+    'ServerInterceptor',
+    'insecure_channel',
+    'server',
+    'Server',
+    'ServicerContext',
+    'EOF',
+    'secure_channel',
+    'AbortError',
+    'BaseError',
+    'UsageError',
+    'InternalError',
+    'Metadata',
+)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_call.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_call.py
index efa88864d1..4ccbb3be13 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_call.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_call.py
@@ -1,244 +1,244 @@
-# Copyright 2019 The gRPC Authors 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Abstract base classes for client-side Call objects. 
- 
-Call objects represents the RPC itself, and offer methods to access / modify 
-its information. They also offer methods to manipulate the life-cycle of the 
-RPC, e.g. cancellation. 
-""" 
- 
-from abc import ABCMeta, abstractmethod 
-from typing import AsyncIterable, Awaitable, Generic, Optional, Union 
- 
-import grpc 
- 
-from ._typing import (DoneCallbackType, EOFType, RequestType, ResponseType) 
-from ._metadata import Metadata 
- 
-__all__ = 'RpcContext', 'Call', 'UnaryUnaryCall', 'UnaryStreamCall' 
- 
- 
-class RpcContext(metaclass=ABCMeta): 
-    """Provides RPC-related information and action.""" 
- 
-    @abstractmethod 
-    def cancelled(self) -> bool: 
-        """Return True if the RPC is cancelled. 
- 
-        The RPC is cancelled when the cancellation was requested with cancel(). 
- 
-        Returns: 
-          A bool indicates whether the RPC is cancelled or not. 
-        """ 
- 
-    @abstractmethod 
-    def done(self) -> bool: 
-        """Return True if the RPC is done. 
- 
-        An RPC is done if the RPC is completed, cancelled or aborted. 
- 
-        Returns: 
-          A bool indicates if the RPC is done. 
-        """ 
- 
-    @abstractmethod 
-    def time_remaining(self) -> Optional[float]: 
-        """Describes the length of allowed time remaining for the RPC. 
- 
-        Returns: 
-          A nonnegative float indicating the length of allowed time in seconds 
-          remaining for the RPC to complete before it is considered to have 
-          timed out, or None if no deadline was specified for the RPC. 
-        """ 
- 
-    @abstractmethod 
-    def cancel(self) -> bool: 
-        """Cancels the RPC. 
- 
-        Idempotent and has no effect if the RPC has already terminated. 
- 
-        Returns: 
-          A bool indicates if the cancellation is performed or not. 
-        """ 
- 
-    @abstractmethod 
-    def add_done_callback(self, callback: DoneCallbackType) -> None: 
-        """Registers a callback to be called on RPC termination. 
- 
-        Args: 
-          callback: A callable object will be called with the call object as 
-          its only argument. 
-        """ 
- 
- 
-class Call(RpcContext, metaclass=ABCMeta): 
-    """The abstract base class of an RPC on the client-side.""" 
- 
-    @abstractmethod 
-    async def initial_metadata(self) -> Metadata: 
-        """Accesses the initial metadata sent by the server. 
- 
-        Returns: 
-          The initial :term:`metadata`. 
-        """ 
- 
-    @abstractmethod 
-    async def trailing_metadata(self) -> Metadata: 
-        """Accesses the trailing metadata sent by the server. 
- 
-        Returns: 
-          The trailing :term:`metadata`. 
-        """ 
- 
-    @abstractmethod 
-    async def code(self) -> grpc.StatusCode: 
-        """Accesses the status code sent by the server. 
- 
-        Returns: 
-          The StatusCode value for the RPC. 
-        """ 
- 
-    @abstractmethod 
-    async def details(self) -> str: 
-        """Accesses the details sent by the server. 
- 
-        Returns: 
-          The details string of the RPC. 
-        """ 
- 
-    @abstractmethod 
-    async def wait_for_connection(self) -> None: 
-        """Waits until connected to peer and raises aio.AioRpcError if failed. 
- 
-        This is an EXPERIMENTAL method. 
- 
-        This method ensures the RPC has been successfully connected. Otherwise, 
-        an AioRpcError will be raised to explain the reason of the connection 
-        failure. 
- 
-        This method is recommended for building retry mechanisms. 
-        """ 
- 
- 
-class UnaryUnaryCall(Generic[RequestType, ResponseType], 
-                     Call, 
-                     metaclass=ABCMeta): 
-    """The abstract base class of an unary-unary RPC on the client-side.""" 
- 
-    @abstractmethod 
-    def __await__(self) -> Awaitable[ResponseType]: 
-        """Await the response message to be ready. 
- 
-        Returns: 
-          The response message of the RPC. 
-        """ 
- 
- 
-class UnaryStreamCall(Generic[RequestType, ResponseType], 
-                      Call, 
-                      metaclass=ABCMeta): 
- 
-    @abstractmethod 
-    def __aiter__(self) -> AsyncIterable[ResponseType]: 
-        """Returns the async iterable representation that yields messages. 
- 
-        Under the hood, it is calling the "read" method. 
- 
-        Returns: 
-          An async iterable object that yields messages. 
-        """ 
- 
-    @abstractmethod 
-    async def read(self) -> Union[EOFType, ResponseType]: 
-        """Reads one message from the stream. 
- 
-        Read operations must be serialized when called from multiple 
-        coroutines. 
- 
-        Returns: 
-          A response message, or an `grpc.aio.EOF` to indicate the end of the 
-          stream. 
-        """ 
- 
- 
-class StreamUnaryCall(Generic[RequestType, ResponseType], 
-                      Call, 
-                      metaclass=ABCMeta): 
- 
-    @abstractmethod 
-    async def write(self, request: RequestType) -> None: 
-        """Writes one message to the stream. 
- 
-        Raises: 
-          An RpcError exception if the write failed. 
-        """ 
- 
-    @abstractmethod 
-    async def done_writing(self) -> None: 
-        """Notifies server that the client is done sending messages. 
- 
-        After done_writing is called, any additional invocation to the write 
-        function will fail. This function is idempotent. 
-        """ 
- 
-    @abstractmethod 
-    def __await__(self) -> Awaitable[ResponseType]: 
-        """Await the response message to be ready. 
- 
-        Returns: 
-          The response message of the stream. 
-        """ 
- 
- 
-class StreamStreamCall(Generic[RequestType, ResponseType], 
-                       Call, 
-                       metaclass=ABCMeta): 
- 
-    @abstractmethod 
-    def __aiter__(self) -> AsyncIterable[ResponseType]: 
-        """Returns the async iterable representation that yields messages. 
- 
-        Under the hood, it is calling the "read" method. 
- 
-        Returns: 
-          An async iterable object that yields messages. 
-        """ 
- 
-    @abstractmethod 
-    async def read(self) -> Union[EOFType, ResponseType]: 
-        """Reads one message from the stream. 
- 
-        Read operations must be serialized when called from multiple 
-        coroutines. 
- 
-        Returns: 
-          A response message, or an `grpc.aio.EOF` to indicate the end of the 
-          stream. 
-        """ 
- 
-    @abstractmethod 
-    async def write(self, request: RequestType) -> None: 
-        """Writes one message to the stream. 
- 
-        Raises: 
-          An RpcError exception if the write failed. 
-        """ 
- 
-    @abstractmethod 
-    async def done_writing(self) -> None: 
-        """Notifies server that the client is done sending messages. 
- 
-        After done_writing is called, any additional invocation to the write 
-        function will fail. This function is idempotent. 
-        """ 
+# Copyright 2019 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Abstract base classes for client-side Call objects.
+
+Call objects represents the RPC itself, and offer methods to access / modify
+its information. They also offer methods to manipulate the life-cycle of the
+RPC, e.g. cancellation.
+"""
+
+from abc import ABCMeta, abstractmethod
+from typing import AsyncIterable, Awaitable, Generic, Optional, Union
+
+import grpc
+
+from ._typing import (DoneCallbackType, EOFType, RequestType, ResponseType)
+from ._metadata import Metadata
+
+__all__ = 'RpcContext', 'Call', 'UnaryUnaryCall', 'UnaryStreamCall'
+
+
+class RpcContext(metaclass=ABCMeta):
+    """Provides RPC-related information and action."""
+
+    @abstractmethod
+    def cancelled(self) -> bool:
+        """Return True if the RPC is cancelled.
+
+        The RPC is cancelled when the cancellation was requested with cancel().
+
+        Returns:
+          A bool indicates whether the RPC is cancelled or not.
+        """
+
+    @abstractmethod
+    def done(self) -> bool:
+        """Return True if the RPC is done.
+
+        An RPC is done if the RPC is completed, cancelled or aborted.
+
+        Returns:
+          A bool indicates if the RPC is done.
+        """
+
+    @abstractmethod
+    def time_remaining(self) -> Optional[float]:
+        """Describes the length of allowed time remaining for the RPC.
+
+        Returns:
+          A nonnegative float indicating the length of allowed time in seconds
+          remaining for the RPC to complete before it is considered to have
+          timed out, or None if no deadline was specified for the RPC.
+        """
+
+    @abstractmethod
+    def cancel(self) -> bool:
+        """Cancels the RPC.
+
+        Idempotent and has no effect if the RPC has already terminated.
+
+        Returns:
+          A bool indicates if the cancellation is performed or not.
+        """
+
+    @abstractmethod
+    def add_done_callback(self, callback: DoneCallbackType) -> None:
+        """Registers a callback to be called on RPC termination.
+
+        Args:
+          callback: A callable object will be called with the call object as
+          its only argument.
+        """
+
+
+class Call(RpcContext, metaclass=ABCMeta):
+    """The abstract base class of an RPC on the client-side."""
+
+    @abstractmethod
+    async def initial_metadata(self) -> Metadata:
+        """Accesses the initial metadata sent by the server.
+
+        Returns:
+          The initial :term:`metadata`.
+        """
+
+    @abstractmethod
+    async def trailing_metadata(self) -> Metadata:
+        """Accesses the trailing metadata sent by the server.
+
+        Returns:
+          The trailing :term:`metadata`.
+        """
+
+    @abstractmethod
+    async def code(self) -> grpc.StatusCode:
+        """Accesses the status code sent by the server.
+
+        Returns:
+          The StatusCode value for the RPC.
+        """
+
+    @abstractmethod
+    async def details(self) -> str:
+        """Accesses the details sent by the server.
+
+        Returns:
+          The details string of the RPC.
+        """
+
+    @abstractmethod
+    async def wait_for_connection(self) -> None:
+        """Waits until connected to peer and raises aio.AioRpcError if failed.
+
+        This is an EXPERIMENTAL method.
+
+        This method ensures the RPC has been successfully connected. Otherwise,
+        an AioRpcError will be raised to explain the reason of the connection
+        failure.
+
+        This method is recommended for building retry mechanisms.
+        """
+
+
+class UnaryUnaryCall(Generic[RequestType, ResponseType],
+                     Call,
+                     metaclass=ABCMeta):
+    """The abstract base class of an unary-unary RPC on the client-side."""
+
+    @abstractmethod
+    def __await__(self) -> Awaitable[ResponseType]:
+        """Await the response message to be ready.
+
+        Returns:
+          The response message of the RPC.
+        """
+
+
+class UnaryStreamCall(Generic[RequestType, ResponseType],
+                      Call,
+                      metaclass=ABCMeta):
+
+    @abstractmethod
+    def __aiter__(self) -> AsyncIterable[ResponseType]:
+        """Returns the async iterable representation that yields messages.
+
+        Under the hood, it is calling the "read" method.
+
+        Returns:
+          An async iterable object that yields messages.
+        """
+
+    @abstractmethod
+    async def read(self) -> Union[EOFType, ResponseType]:
+        """Reads one message from the stream.
+
+        Read operations must be serialized when called from multiple
+        coroutines.
+
+        Returns:
+          A response message, or an `grpc.aio.EOF` to indicate the end of the
+          stream.
+        """
+
+
+class StreamUnaryCall(Generic[RequestType, ResponseType],
+                      Call,
+                      metaclass=ABCMeta):
+
+    @abstractmethod
+    async def write(self, request: RequestType) -> None:
+        """Writes one message to the stream.
+
+        Raises:
+          An RpcError exception if the write failed.
+        """
+
+    @abstractmethod
+    async def done_writing(self) -> None:
+        """Notifies server that the client is done sending messages.
+
+        After done_writing is called, any additional invocation to the write
+        function will fail. This function is idempotent.
+        """
+
+    @abstractmethod
+    def __await__(self) -> Awaitable[ResponseType]:
+        """Await the response message to be ready.
+
+        Returns:
+          The response message of the stream.
+        """
+
+
+class StreamStreamCall(Generic[RequestType, ResponseType],
+                       Call,
+                       metaclass=ABCMeta):
+
+    @abstractmethod
+    def __aiter__(self) -> AsyncIterable[ResponseType]:
+        """Returns the async iterable representation that yields messages.
+
+        Under the hood, it is calling the "read" method.
+
+        Returns:
+          An async iterable object that yields messages.
+        """
+
+    @abstractmethod
+    async def read(self) -> Union[EOFType, ResponseType]:
+        """Reads one message from the stream.
+
+        Read operations must be serialized when called from multiple
+        coroutines.
+
+        Returns:
+          A response message, or an `grpc.aio.EOF` to indicate the end of the
+          stream.
+        """
+
+    @abstractmethod
+    async def write(self, request: RequestType) -> None:
+        """Writes one message to the stream.
+
+        Raises:
+          An RpcError exception if the write failed.
+        """
+
+    @abstractmethod
+    async def done_writing(self) -> None:
+        """Notifies server that the client is done sending messages.
+
+        After done_writing is called, any additional invocation to the write
+        function will fail. This function is idempotent.
+        """
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_channel.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_channel.py
index 8d852a1b9c..4b4ea1355b 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_channel.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_channel.py
@@ -1,347 +1,347 @@
-# Copyright 2020 The gRPC Authors 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Abstract base classes for Channel objects and Multicallable objects.""" 
- 
-import abc 
-from typing import Any, Optional 
- 
-import grpc 
- 
-from . import _base_call 
-from ._typing import (DeserializingFunction, RequestIterableType, 
-                      SerializingFunction) 
-from ._metadata import Metadata 
- 
- 
-class UnaryUnaryMultiCallable(abc.ABC): 
-    """Enables asynchronous invocation of a unary-call RPC.""" 
- 
-    @abc.abstractmethod 
-    def __call__(self, 
-                 request: Any, 
-                 *, 
-                 timeout: Optional[float] = None, 
-                 metadata: Optional[Metadata] = None, 
-                 credentials: Optional[grpc.CallCredentials] = None, 
-                 wait_for_ready: Optional[bool] = None, 
-                 compression: Optional[grpc.Compression] = None 
-                ) -> _base_call.UnaryUnaryCall: 
-        """Asynchronously invokes the underlying RPC. 
- 
-        Args: 
-          request: The request value for the RPC. 
-          timeout: An optional duration of time in seconds to allow 
-            for the RPC. 
-          metadata: Optional :term:`metadata` to be transmitted to the 
-            service-side of the RPC. 
-          credentials: An optional CallCredentials for the RPC. Only valid for 
-            secure Channel. 
-          wait_for_ready: This is an EXPERIMENTAL argument. An optional 
-            flag to enable :term:`wait_for_ready` mechanism. 
-          compression: An element of grpc.compression, e.g. 
-            grpc.compression.Gzip. This is an EXPERIMENTAL option. 
- 
-        Returns: 
-          A UnaryUnaryCall object. 
- 
-        Raises: 
-          RpcError: Indicates that the RPC terminated with non-OK status. The 
-            raised RpcError will also be a Call for the RPC affording the RPC's 
-            metadata, status code, and details. 
-        """ 
- 
- 
-class UnaryStreamMultiCallable(abc.ABC): 
-    """Enables asynchronous invocation of a server-streaming RPC.""" 
- 
-    @abc.abstractmethod 
-    def __call__(self, 
-                 request: Any, 
-                 *, 
-                 timeout: Optional[float] = None, 
-                 metadata: Optional[Metadata] = None, 
-                 credentials: Optional[grpc.CallCredentials] = None, 
-                 wait_for_ready: Optional[bool] = None, 
-                 compression: Optional[grpc.Compression] = None 
-                ) -> _base_call.UnaryStreamCall: 
-        """Asynchronously invokes the underlying RPC. 
- 
-        Args: 
-          request: The request value for the RPC. 
-          timeout: An optional duration of time in seconds to allow 
-            for the RPC. 
-          metadata: Optional :term:`metadata` to be transmitted to the 
-            service-side of the RPC. 
-          credentials: An optional CallCredentials for the RPC. Only valid for 
-            secure Channel. 
-          wait_for_ready: This is an EXPERIMENTAL argument. An optional 
-            flag to enable :term:`wait_for_ready` mechanism. 
-          compression: An element of grpc.compression, e.g. 
-            grpc.compression.Gzip. This is an EXPERIMENTAL option. 
- 
-        Returns: 
-          A UnaryStreamCall object. 
- 
-        Raises: 
-          RpcError: Indicates that the RPC terminated with non-OK status. The 
-            raised RpcError will also be a Call for the RPC affording the RPC's 
-            metadata, status code, and details. 
-        """ 
- 
- 
-class StreamUnaryMultiCallable(abc.ABC): 
-    """Enables asynchronous invocation of a client-streaming RPC.""" 
- 
-    @abc.abstractmethod 
-    def __call__(self, 
-                 request_iterator: Optional[RequestIterableType] = None, 
-                 timeout: Optional[float] = None, 
-                 metadata: Optional[Metadata] = None, 
-                 credentials: Optional[grpc.CallCredentials] = None, 
-                 wait_for_ready: Optional[bool] = None, 
-                 compression: Optional[grpc.Compression] = None 
-                ) -> _base_call.StreamUnaryCall: 
-        """Asynchronously invokes the underlying RPC. 
- 
-        Args: 
-          request_iterator: An optional async iterable or iterable of request 
-            messages for the RPC. 
-          timeout: An optional duration of time in seconds to allow 
-            for the RPC. 
-          metadata: Optional :term:`metadata` to be transmitted to the 
-            service-side of the RPC. 
-          credentials: An optional CallCredentials for the RPC. Only valid for 
-            secure Channel. 
-          wait_for_ready: This is an EXPERIMENTAL argument. An optional 
-            flag to enable :term:`wait_for_ready` mechanism. 
-          compression: An element of grpc.compression, e.g. 
-            grpc.compression.Gzip. This is an EXPERIMENTAL option. 
- 
-        Returns: 
-          A StreamUnaryCall object. 
- 
-        Raises: 
-          RpcError: Indicates that the RPC terminated with non-OK status. The 
-            raised RpcError will also be a Call for the RPC affording the RPC's 
-            metadata, status code, and details. 
-        """ 
- 
- 
-class StreamStreamMultiCallable(abc.ABC): 
-    """Enables asynchronous invocation of a bidirectional-streaming RPC.""" 
- 
-    @abc.abstractmethod 
-    def __call__(self, 
-                 request_iterator: Optional[RequestIterableType] = None, 
-                 timeout: Optional[float] = None, 
-                 metadata: Optional[Metadata] = None, 
-                 credentials: Optional[grpc.CallCredentials] = None, 
-                 wait_for_ready: Optional[bool] = None, 
-                 compression: Optional[grpc.Compression] = None 
-                ) -> _base_call.StreamStreamCall: 
-        """Asynchronously invokes the underlying RPC. 
- 
-        Args: 
-          request_iterator: An optional async iterable or iterable of request 
-            messages for the RPC. 
-          timeout: An optional duration of time in seconds to allow 
-            for the RPC. 
-          metadata: Optional :term:`metadata` to be transmitted to the 
-            service-side of the RPC. 
-          credentials: An optional CallCredentials for the RPC. Only valid for 
-            secure Channel. 
-          wait_for_ready: This is an EXPERIMENTAL argument. An optional 
-            flag to enable :term:`wait_for_ready` mechanism. 
-          compression: An element of grpc.compression, e.g. 
-            grpc.compression.Gzip. This is an EXPERIMENTAL option. 
- 
-        Returns: 
-          A StreamStreamCall object. 
- 
-        Raises: 
-          RpcError: Indicates that the RPC terminated with non-OK status. The 
-            raised RpcError will also be a Call for the RPC affording the RPC's 
-            metadata, status code, and details. 
-        """ 
- 
- 
-class Channel(abc.ABC): 
-    """Enables asynchronous RPC invocation as a client. 
- 
-    Channel objects implement the Asynchronous Context Manager (aka. async 
-    with) type, although they are not supportted to be entered and exited 
-    multiple times. 
-    """ 
- 
-    @abc.abstractmethod 
-    async def __aenter__(self): 
-        """Starts an asynchronous context manager. 
- 
-        Returns: 
-          Channel the channel that was instantiated. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def __aexit__(self, exc_type, exc_val, exc_tb): 
-        """Finishes the asynchronous context manager by closing the channel. 
- 
-        Still active RPCs will be cancelled. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def close(self, grace: Optional[float] = None): 
-        """Closes this Channel and releases all resources held by it. 
- 
-        This method immediately stops the channel from executing new RPCs in 
-        all cases. 
- 
-        If a grace period is specified, this method wait until all active 
-        RPCs are finshed, once the grace period is reached the ones that haven't 
-        been terminated are cancelled. If a grace period is not specified 
-        (by passing None for grace), all existing RPCs are cancelled immediately. 
- 
-        This method is idempotent. 
-        """ 
- 
-    @abc.abstractmethod 
-    def get_state(self, 
-                  try_to_connect: bool = False) -> grpc.ChannelConnectivity: 
-        """Checks the connectivity state of a channel. 
- 
-        This is an EXPERIMENTAL API. 
- 
-        If the channel reaches a stable connectivity state, it is guaranteed 
-        that the return value of this function will eventually converge to that 
-        state. 
- 
-        Args: 
-          try_to_connect: a bool indicate whether the Channel should try to 
-            connect to peer or not. 
- 
-        Returns: A ChannelConnectivity object. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def wait_for_state_change( 
-            self, 
-            last_observed_state: grpc.ChannelConnectivity, 
-    ) -> None: 
-        """Waits for a change in connectivity state. 
- 
-        This is an EXPERIMENTAL API. 
- 
-        The function blocks until there is a change in the channel connectivity 
-        state from the "last_observed_state". If the state is already 
-        different, this function will return immediately. 
- 
-        There is an inherent race between the invocation of 
-        "Channel.wait_for_state_change" and "Channel.get_state". The state can 
-        change arbitrary many times during the race, so there is no way to 
-        observe every state transition. 
- 
-        If there is a need to put a timeout for this function, please refer to 
-        "asyncio.wait_for". 
- 
-        Args: 
-          last_observed_state: A grpc.ChannelConnectivity object representing 
-            the last known state. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def channel_ready(self) -> None: 
-        """Creates a coroutine that blocks until the Channel is READY.""" 
- 
-    @abc.abstractmethod 
-    def unary_unary( 
-            self, 
-            method: str, 
-            request_serializer: Optional[SerializingFunction] = None, 
-            response_deserializer: Optional[DeserializingFunction] = None 
-    ) -> UnaryUnaryMultiCallable: 
-        """Creates a UnaryUnaryMultiCallable for a unary-unary method. 
- 
-        Args: 
-          method: The name of the RPC method. 
-          request_serializer: Optional :term:`serializer` for serializing the request 
-            message. Request goes unserialized in case None is passed. 
-          response_deserializer: Optional :term:`deserializer` for deserializing the 
-            response message. Response goes undeserialized in case None 
-            is passed. 
- 
-        Returns: 
-          A UnaryUnaryMultiCallable value for the named unary-unary method. 
-        """ 
- 
-    @abc.abstractmethod 
-    def unary_stream( 
-            self, 
-            method: str, 
-            request_serializer: Optional[SerializingFunction] = None, 
-            response_deserializer: Optional[DeserializingFunction] = None 
-    ) -> UnaryStreamMultiCallable: 
-        """Creates a UnaryStreamMultiCallable for a unary-stream method. 
- 
-        Args: 
-          method: The name of the RPC method. 
-          request_serializer: Optional :term:`serializer` for serializing the request 
-            message. Request goes unserialized in case None is passed. 
-          response_deserializer: Optional :term:`deserializer` for deserializing the 
-            response message. Response goes undeserialized in case None 
-            is passed. 
- 
-        Returns: 
-          A UnarySteramMultiCallable value for the named unary-stream method. 
-        """ 
- 
-    @abc.abstractmethod 
-    def stream_unary( 
-            self, 
-            method: str, 
-            request_serializer: Optional[SerializingFunction] = None, 
-            response_deserializer: Optional[DeserializingFunction] = None 
-    ) -> StreamUnaryMultiCallable: 
-        """Creates a StreamUnaryMultiCallable for a stream-unary method. 
- 
-        Args: 
-          method: The name of the RPC method. 
-          request_serializer: Optional :term:`serializer` for serializing the request 
-            message. Request goes unserialized in case None is passed. 
-          response_deserializer: Optional :term:`deserializer` for deserializing the 
-            response message. Response goes undeserialized in case None 
-            is passed. 
- 
-        Returns: 
-          A StreamUnaryMultiCallable value for the named stream-unary method. 
-        """ 
- 
-    @abc.abstractmethod 
-    def stream_stream( 
-            self, 
-            method: str, 
-            request_serializer: Optional[SerializingFunction] = None, 
-            response_deserializer: Optional[DeserializingFunction] = None 
-    ) -> StreamStreamMultiCallable: 
-        """Creates a StreamStreamMultiCallable for a stream-stream method. 
- 
-        Args: 
-          method: The name of the RPC method. 
-          request_serializer: Optional :term:`serializer` for serializing the request 
-            message. Request goes unserialized in case None is passed. 
-          response_deserializer: Optional :term:`deserializer` for deserializing the 
-            response message. Response goes undeserialized in case None 
-            is passed. 
- 
-        Returns: 
-          A StreamStreamMultiCallable value for the named stream-stream method. 
-        """ 
+# Copyright 2020 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Abstract base classes for Channel objects and Multicallable objects."""
+
+import abc
+from typing import Any, Optional
+
+import grpc
+
+from . import _base_call
+from ._typing import (DeserializingFunction, RequestIterableType,
+                      SerializingFunction)
+from ._metadata import Metadata
+
+
+class UnaryUnaryMultiCallable(abc.ABC):
+    """Enables asynchronous invocation of a unary-call RPC."""
+
+    @abc.abstractmethod
+    def __call__(self,
+                 request: Any,
+                 *,
+                 timeout: Optional[float] = None,
+                 metadata: Optional[Metadata] = None,
+                 credentials: Optional[grpc.CallCredentials] = None,
+                 wait_for_ready: Optional[bool] = None,
+                 compression: Optional[grpc.Compression] = None
+                ) -> _base_call.UnaryUnaryCall:
+        """Asynchronously invokes the underlying RPC.
+
+        Args:
+          request: The request value for the RPC.
+          timeout: An optional duration of time in seconds to allow
+            for the RPC.
+          metadata: Optional :term:`metadata` to be transmitted to the
+            service-side of the RPC.
+          credentials: An optional CallCredentials for the RPC. Only valid for
+            secure Channel.
+          wait_for_ready: This is an EXPERIMENTAL argument. An optional
+            flag to enable :term:`wait_for_ready` mechanism.
+          compression: An element of grpc.compression, e.g.
+            grpc.compression.Gzip. This is an EXPERIMENTAL option.
+
+        Returns:
+          A UnaryUnaryCall object.
+
+        Raises:
+          RpcError: Indicates that the RPC terminated with non-OK status. The
+            raised RpcError will also be a Call for the RPC affording the RPC's
+            metadata, status code, and details.
+        """
+
+
+class UnaryStreamMultiCallable(abc.ABC):
+    """Enables asynchronous invocation of a server-streaming RPC."""
+
+    @abc.abstractmethod
+    def __call__(self,
+                 request: Any,
+                 *,
+                 timeout: Optional[float] = None,
+                 metadata: Optional[Metadata] = None,
+                 credentials: Optional[grpc.CallCredentials] = None,
+                 wait_for_ready: Optional[bool] = None,
+                 compression: Optional[grpc.Compression] = None
+                ) -> _base_call.UnaryStreamCall:
+        """Asynchronously invokes the underlying RPC.
+
+        Args:
+          request: The request value for the RPC.
+          timeout: An optional duration of time in seconds to allow
+            for the RPC.
+          metadata: Optional :term:`metadata` to be transmitted to the
+            service-side of the RPC.
+          credentials: An optional CallCredentials for the RPC. Only valid for
+            secure Channel.
+          wait_for_ready: This is an EXPERIMENTAL argument. An optional
+            flag to enable :term:`wait_for_ready` mechanism.
+          compression: An element of grpc.compression, e.g.
+            grpc.compression.Gzip. This is an EXPERIMENTAL option.
+
+        Returns:
+          A UnaryStreamCall object.
+
+        Raises:
+          RpcError: Indicates that the RPC terminated with non-OK status. The
+            raised RpcError will also be a Call for the RPC affording the RPC's
+            metadata, status code, and details.
+        """
+
+
+class StreamUnaryMultiCallable(abc.ABC):
+    """Enables asynchronous invocation of a client-streaming RPC."""
+
+    @abc.abstractmethod
+    def __call__(self,
+                 request_iterator: Optional[RequestIterableType] = None,
+                 timeout: Optional[float] = None,
+                 metadata: Optional[Metadata] = None,
+                 credentials: Optional[grpc.CallCredentials] = None,
+                 wait_for_ready: Optional[bool] = None,
+                 compression: Optional[grpc.Compression] = None
+                ) -> _base_call.StreamUnaryCall:
+        """Asynchronously invokes the underlying RPC.
+
+        Args:
+          request_iterator: An optional async iterable or iterable of request
+            messages for the RPC.
+          timeout: An optional duration of time in seconds to allow
+            for the RPC.
+          metadata: Optional :term:`metadata` to be transmitted to the
+            service-side of the RPC.
+          credentials: An optional CallCredentials for the RPC. Only valid for
+            secure Channel.
+          wait_for_ready: This is an EXPERIMENTAL argument. An optional
+            flag to enable :term:`wait_for_ready` mechanism.
+          compression: An element of grpc.compression, e.g.
+            grpc.compression.Gzip. This is an EXPERIMENTAL option.
+
+        Returns:
+          A StreamUnaryCall object.
+
+        Raises:
+          RpcError: Indicates that the RPC terminated with non-OK status. The
+            raised RpcError will also be a Call for the RPC affording the RPC's
+            metadata, status code, and details.
+        """
+
+
+class StreamStreamMultiCallable(abc.ABC):
+    """Enables asynchronous invocation of a bidirectional-streaming RPC."""
+
+    @abc.abstractmethod
+    def __call__(self,
+                 request_iterator: Optional[RequestIterableType] = None,
+                 timeout: Optional[float] = None,
+                 metadata: Optional[Metadata] = None,
+                 credentials: Optional[grpc.CallCredentials] = None,
+                 wait_for_ready: Optional[bool] = None,
+                 compression: Optional[grpc.Compression] = None
+                ) -> _base_call.StreamStreamCall:
+        """Asynchronously invokes the underlying RPC.
+
+        Args:
+          request_iterator: An optional async iterable or iterable of request
+            messages for the RPC.
+          timeout: An optional duration of time in seconds to allow
+            for the RPC.
+          metadata: Optional :term:`metadata` to be transmitted to the
+            service-side of the RPC.
+          credentials: An optional CallCredentials for the RPC. Only valid for
+            secure Channel.
+          wait_for_ready: This is an EXPERIMENTAL argument. An optional
+            flag to enable :term:`wait_for_ready` mechanism.
+          compression: An element of grpc.compression, e.g.
+            grpc.compression.Gzip. This is an EXPERIMENTAL option.
+
+        Returns:
+          A StreamStreamCall object.
+
+        Raises:
+          RpcError: Indicates that the RPC terminated with non-OK status. The
+            raised RpcError will also be a Call for the RPC affording the RPC's
+            metadata, status code, and details.
+        """
+
+
+class Channel(abc.ABC):
+    """Enables asynchronous RPC invocation as a client.
+
+    Channel objects implement the Asynchronous Context Manager (aka. async
+    with) type, although they are not supportted to be entered and exited
+    multiple times.
+    """
+
+    @abc.abstractmethod
+    async def __aenter__(self):
+        """Starts an asynchronous context manager.
+
+        Returns:
+          Channel the channel that was instantiated.
+        """
+
+    @abc.abstractmethod
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Finishes the asynchronous context manager by closing the channel.
+
+        Still active RPCs will be cancelled.
+        """
+
+    @abc.abstractmethod
+    async def close(self, grace: Optional[float] = None):
+        """Closes this Channel and releases all resources held by it.
+
+        This method immediately stops the channel from executing new RPCs in
+        all cases.
+
+        If a grace period is specified, this method wait until all active
+        RPCs are finshed, once the grace period is reached the ones that haven't
+        been terminated are cancelled. If a grace period is not specified
+        (by passing None for grace), all existing RPCs are cancelled immediately.
+
+        This method is idempotent.
+        """
+
+    @abc.abstractmethod
+    def get_state(self,
+                  try_to_connect: bool = False) -> grpc.ChannelConnectivity:
+        """Checks the connectivity state of a channel.
+
+        This is an EXPERIMENTAL API.
+
+        If the channel reaches a stable connectivity state, it is guaranteed
+        that the return value of this function will eventually converge to that
+        state.
+
+        Args:
+          try_to_connect: a bool indicate whether the Channel should try to
+            connect to peer or not.
+
+        Returns: A ChannelConnectivity object.
+        """
+
+    @abc.abstractmethod
+    async def wait_for_state_change(
+            self,
+            last_observed_state: grpc.ChannelConnectivity,
+    ) -> None:
+        """Waits for a change in connectivity state.
+
+        This is an EXPERIMENTAL API.
+
+        The function blocks until there is a change in the channel connectivity
+        state from the "last_observed_state". If the state is already
+        different, this function will return immediately.
+
+        There is an inherent race between the invocation of
+        "Channel.wait_for_state_change" and "Channel.get_state". The state can
+        change arbitrary many times during the race, so there is no way to
+        observe every state transition.
+
+        If there is a need to put a timeout for this function, please refer to
+        "asyncio.wait_for".
+
+        Args:
+          last_observed_state: A grpc.ChannelConnectivity object representing
+            the last known state.
+        """
+
+    @abc.abstractmethod
+    async def channel_ready(self) -> None:
+        """Creates a coroutine that blocks until the Channel is READY."""
+
+    @abc.abstractmethod
+    def unary_unary(
+            self,
+            method: str,
+            request_serializer: Optional[SerializingFunction] = None,
+            response_deserializer: Optional[DeserializingFunction] = None
+    ) -> UnaryUnaryMultiCallable:
+        """Creates a UnaryUnaryMultiCallable for a unary-unary method.
+
+        Args:
+          method: The name of the RPC method.
+          request_serializer: Optional :term:`serializer` for serializing the request
+            message. Request goes unserialized in case None is passed.
+          response_deserializer: Optional :term:`deserializer` for deserializing the
+            response message. Response goes undeserialized in case None
+            is passed.
+
+        Returns:
+          A UnaryUnaryMultiCallable value for the named unary-unary method.
+        """
+
+    @abc.abstractmethod
+    def unary_stream(
+            self,
+            method: str,
+            request_serializer: Optional[SerializingFunction] = None,
+            response_deserializer: Optional[DeserializingFunction] = None
+    ) -> UnaryStreamMultiCallable:
+        """Creates a UnaryStreamMultiCallable for a unary-stream method.
+
+        Args:
+          method: The name of the RPC method.
+          request_serializer: Optional :term:`serializer` for serializing the request
+            message. Request goes unserialized in case None is passed.
+          response_deserializer: Optional :term:`deserializer` for deserializing the
+            response message. Response goes undeserialized in case None
+            is passed.
+
+        Returns:
+          A UnarySteramMultiCallable value for the named unary-stream method.
+        """
+
+    @abc.abstractmethod
+    def stream_unary(
+            self,
+            method: str,
+            request_serializer: Optional[SerializingFunction] = None,
+            response_deserializer: Optional[DeserializingFunction] = None
+    ) -> StreamUnaryMultiCallable:
+        """Creates a StreamUnaryMultiCallable for a stream-unary method.
+
+        Args:
+          method: The name of the RPC method.
+          request_serializer: Optional :term:`serializer` for serializing the request
+            message. Request goes unserialized in case None is passed.
+          response_deserializer: Optional :term:`deserializer` for deserializing the
+            response message. Response goes undeserialized in case None
+            is passed.
+
+        Returns:
+          A StreamUnaryMultiCallable value for the named stream-unary method.
+        """
+
+    @abc.abstractmethod
+    def stream_stream(
+            self,
+            method: str,
+            request_serializer: Optional[SerializingFunction] = None,
+            response_deserializer: Optional[DeserializingFunction] = None
+    ) -> StreamStreamMultiCallable:
+        """Creates a StreamStreamMultiCallable for a stream-stream method.
+
+        Args:
+          method: The name of the RPC method.
+          request_serializer: Optional :term:`serializer` for serializing the request
+            message. Request goes unserialized in case None is passed.
+          response_deserializer: Optional :term:`deserializer` for deserializing the
+            response message. Response goes undeserialized in case None
+            is passed.
+
+        Returns:
+          A StreamStreamMultiCallable value for the named stream-stream method.
+        """
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_server.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_server.py
index 69ec5075ab..926c865171 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_server.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_base_server.py
@@ -1,294 +1,294 @@
-# Copyright 2020 The gRPC Authors 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Abstract base classes for server-side classes.""" 
- 
-import abc 
-from typing import Generic, Mapping, Optional, Iterable, Sequence 
- 
-import grpc 
- 
-from ._typing import RequestType, ResponseType 
-from ._metadata import Metadata 
- 
- 
-class Server(abc.ABC): 
-    """Serves RPCs.""" 
- 
-    @abc.abstractmethod 
-    def add_generic_rpc_handlers( 
-            self, 
-            generic_rpc_handlers: Sequence[grpc.GenericRpcHandler]) -> None: 
-        """Registers GenericRpcHandlers with this Server. 
- 
-        This method is only safe to call before the server is started. 
- 
-        Args: 
-          generic_rpc_handlers: A sequence of GenericRpcHandlers that will be 
-          used to service RPCs. 
-        """ 
- 
-    @abc.abstractmethod 
-    def add_insecure_port(self, address: str) -> int: 
-        """Opens an insecure port for accepting RPCs. 
- 
-        A port is a communication endpoint that used by networking protocols, 
-        like TCP and UDP. To date, we only support TCP. 
- 
-        This method may only be called before starting the server. 
- 
-        Args: 
-          address: The address for which to open a port. If the port is 0, 
-            or not specified in the address, then the gRPC runtime will choose a port. 
- 
-        Returns: 
-          An integer port on which the server will accept RPC requests. 
-        """ 
- 
-    @abc.abstractmethod 
-    def add_secure_port(self, address: str, 
-                        server_credentials: grpc.ServerCredentials) -> int: 
-        """Opens a secure port for accepting RPCs. 
- 
-        A port is a communication endpoint that used by networking protocols, 
-        like TCP and UDP. To date, we only support TCP. 
- 
-        This method may only be called before starting the server. 
- 
-        Args: 
-          address: The address for which to open a port. 
-            if the port is 0, or not specified in the address, then the gRPC 
-            runtime will choose a port. 
-          server_credentials: A ServerCredentials object. 
- 
-        Returns: 
-          An integer port on which the server will accept RPC requests. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def start(self) -> None: 
-        """Starts this Server. 
- 
-        This method may only be called once. (i.e. it is not idempotent). 
-        """ 
- 
-    @abc.abstractmethod 
-    async def stop(self, grace: Optional[float]) -> None: 
-        """Stops this Server. 
- 
-        This method immediately stops the server from servicing new RPCs in 
-        all cases. 
- 
-        If a grace period is specified, this method returns immediately and all 
-        RPCs active at the end of the grace period are aborted. If a grace 
-        period is not specified (by passing None for grace), all existing RPCs 
-        are aborted immediately and this method blocks until the last RPC 
-        handler terminates. 
- 
-        This method is idempotent and may be called at any time. Passing a 
-        smaller grace value in a subsequent call will have the effect of 
-        stopping the Server sooner (passing None will have the effect of 
-        stopping the server immediately). Passing a larger grace value in a 
-        subsequent call will not have the effect of stopping the server later 
-        (i.e. the most restrictive grace value is used). 
- 
-        Args: 
-          grace: A duration of time in seconds or None. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def wait_for_termination(self, 
-                                   timeout: Optional[float] = None) -> bool: 
-        """Continues current coroutine once the server stops. 
- 
-        This is an EXPERIMENTAL API. 
- 
-        The wait will not consume computational resources during blocking, and 
-        it will block until one of the two following conditions are met: 
- 
-        1) The server is stopped or terminated; 
-        2) A timeout occurs if timeout is not `None`. 
- 
-        The timeout argument works in the same way as `threading.Event.wait()`. 
-        https://docs.python.org/3/library/threading.html#threading.Event.wait 
- 
-        Args: 
-          timeout: A floating point number specifying a timeout for the 
-            operation in seconds. 
- 
-        Returns: 
-          A bool indicates if the operation times out. 
-        """ 
- 
- 
-class ServicerContext(Generic[RequestType, ResponseType], abc.ABC): 
-    """A context object passed to method implementations.""" 
- 
-    @abc.abstractmethod 
-    async def read(self) -> RequestType: 
-        """Reads one message from the RPC. 
- 
-        Only one read operation is allowed simultaneously. 
- 
-        Returns: 
-          A response message of the RPC. 
- 
-        Raises: 
-          An RpcError exception if the read failed. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def write(self, message: ResponseType) -> None: 
-        """Writes one message to the RPC. 
- 
-        Only one write operation is allowed simultaneously. 
- 
-        Raises: 
-          An RpcError exception if the write failed. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def send_initial_metadata(self, initial_metadata: Metadata) -> None: 
-        """Sends the initial metadata value to the client. 
- 
-        This method need not be called by implementations if they have no 
-        metadata to add to what the gRPC runtime will transmit. 
- 
-        Args: 
-          initial_metadata: The initial :term:`metadata`. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def abort(self, code: grpc.StatusCode, details: str, 
-                    trailing_metadata: Metadata) -> None: 
-        """Raises an exception to terminate the RPC with a non-OK status. 
- 
-        The code and details passed as arguments will supercede any existing 
-        ones. 
- 
-        Args: 
-          code: A StatusCode object to be sent to the client. 
-            It must not be StatusCode.OK. 
-          details: A UTF-8-encodable string to be sent to the client upon 
-            termination of the RPC. 
-          trailing_metadata: A sequence of tuple represents the trailing 
-            :term:`metadata`. 
- 
-        Raises: 
-          Exception: An exception is always raised to signal the abortion the 
-            RPC to the gRPC runtime. 
-        """ 
- 
-    @abc.abstractmethod 
-    async def set_trailing_metadata(self, trailing_metadata: Metadata) -> None: 
-        """Sends the trailing metadata for the RPC. 
- 
-        This method need not be called by implementations if they have no 
-        metadata to add to what the gRPC runtime will transmit. 
- 
-        Args: 
-          trailing_metadata: The trailing :term:`metadata`. 
-        """ 
- 
-    @abc.abstractmethod 
-    def invocation_metadata(self) -> Optional[Metadata]: 
-        """Accesses the metadata from the sent by the client. 
- 
-        Returns: 
-          The invocation :term:`metadata`. 
-        """ 
- 
-    @abc.abstractmethod 
-    def set_code(self, code: grpc.StatusCode) -> None: 
-        """Sets the value to be used as status code upon RPC completion. 
- 
-        This method need not be called by method implementations if they wish 
-        the gRPC runtime to determine the status code of the RPC. 
- 
-        Args: 
-          code: A StatusCode object to be sent to the client. 
-        """ 
- 
-    @abc.abstractmethod 
-    def set_details(self, details: str) -> None: 
-        """Sets the value to be used the as detail string upon RPC completion. 
- 
-        This method need not be called by method implementations if they have 
-        no details to transmit. 
- 
-        Args: 
-          details: A UTF-8-encodable string to be sent to the client upon 
-            termination of the RPC. 
-        """ 
- 
-    @abc.abstractmethod 
-    def set_compression(self, compression: grpc.Compression) -> None: 
-        """Set the compression algorithm to be used for the entire call. 
- 
-        This is an EXPERIMENTAL method. 
- 
-        Args: 
-          compression: An element of grpc.compression, e.g. 
-            grpc.compression.Gzip. 
-        """ 
- 
-    @abc.abstractmethod 
-    def disable_next_message_compression(self) -> None: 
-        """Disables compression for the next response message. 
- 
-        This is an EXPERIMENTAL method. 
- 
-        This method will override any compression configuration set during 
-        server creation or set on the call. 
-        """ 
- 
-    @abc.abstractmethod 
-    def peer(self) -> str: 
-        """Identifies the peer that invoked the RPC being serviced. 
- 
-        Returns: 
-          A string identifying the peer that invoked the RPC being serviced. 
-          The string format is determined by gRPC runtime. 
-        """ 
- 
-    @abc.abstractmethod 
-    def peer_identities(self) -> Optional[Iterable[bytes]]: 
-        """Gets one or more peer identity(s). 
- 
-        Equivalent to 
-        servicer_context.auth_context().get(servicer_context.peer_identity_key()) 
- 
-        Returns: 
-          An iterable of the identities, or None if the call is not 
-          authenticated. Each identity is returned as a raw bytes type. 
-        """ 
- 
-    @abc.abstractmethod 
-    def peer_identity_key(self) -> Optional[str]: 
-        """The auth property used to identify the peer. 
- 
-        For example, "x509_common_name" or "x509_subject_alternative_name" are 
-        used to identify an SSL peer. 
- 
-        Returns: 
-          The auth property (string) that indicates the 
-          peer identity, or None if the call is not authenticated. 
-        """ 
- 
-    @abc.abstractmethod 
-    def auth_context(self) -> Mapping[str, Iterable[bytes]]: 
-        """Gets the auth context for the call. 
- 
-        Returns: 
-          A map of strings to an iterable of bytes for each auth property. 
-        """ 
+# Copyright 2020 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Abstract base classes for server-side classes."""
+
+import abc
+from typing import Generic, Mapping, Optional, Iterable, Sequence
+
+import grpc
+
+from ._typing import RequestType, ResponseType
+from ._metadata import Metadata
+
+
+class Server(abc.ABC):
+    """Serves RPCs."""
+
+    @abc.abstractmethod
+    def add_generic_rpc_handlers(
+            self,
+            generic_rpc_handlers: Sequence[grpc.GenericRpcHandler]) -> None:
+        """Registers GenericRpcHandlers with this Server.
+
+        This method is only safe to call before the server is started.
+
+        Args:
+          generic_rpc_handlers: A sequence of GenericRpcHandlers that will be
+          used to service RPCs.
+        """
+
+    @abc.abstractmethod
+    def add_insecure_port(self, address: str) -> int:
+        """Opens an insecure port for accepting RPCs.
+
+        A port is a communication endpoint that used by networking protocols,
+        like TCP and UDP. To date, we only support TCP.
+
+        This method may only be called before starting the server.
+
+        Args:
+          address: The address for which to open a port. If the port is 0,
+            or not specified in the address, then the gRPC runtime will choose a port.
+
+        Returns:
+          An integer port on which the server will accept RPC requests.
+        """
+
+    @abc.abstractmethod
+    def add_secure_port(self, address: str,
+                        server_credentials: grpc.ServerCredentials) -> int:
+        """Opens a secure port for accepting RPCs.
+
+        A port is a communication endpoint that used by networking protocols,
+        like TCP and UDP. To date, we only support TCP.
+
+        This method may only be called before starting the server.
+
+        Args:
+          address: The address for which to open a port.
+            if the port is 0, or not specified in the address, then the gRPC
+            runtime will choose a port.
+          server_credentials: A ServerCredentials object.
+
+        Returns:
+          An integer port on which the server will accept RPC requests.
+        """
+
+    @abc.abstractmethod
+    async def start(self) -> None:
+        """Starts this Server.
+
+        This method may only be called once. (i.e. it is not idempotent).
+        """
+
+    @abc.abstractmethod
+    async def stop(self, grace: Optional[float]) -> None:
+        """Stops this Server.
+
+        This method immediately stops the server from servicing new RPCs in
+        all cases.
+
+        If a grace period is specified, this method returns immediately and all
+        RPCs active at the end of the grace period are aborted. If a grace
+        period is not specified (by passing None for grace), all existing RPCs
+        are aborted immediately and this method blocks until the last RPC
+        handler terminates.
+
+        This method is idempotent and may be called at any time. Passing a
+        smaller grace value in a subsequent call will have the effect of
+        stopping the Server sooner (passing None will have the effect of
+        stopping the server immediately). Passing a larger grace value in a
+        subsequent call will not have the effect of stopping the server later
+        (i.e. the most restrictive grace value is used).
+
+        Args:
+          grace: A duration of time in seconds or None.
+        """
+
+    @abc.abstractmethod
+    async def wait_for_termination(self,
+                                   timeout: Optional[float] = None) -> bool:
+        """Continues current coroutine once the server stops.
+
+        This is an EXPERIMENTAL API.
+
+        The wait will not consume computational resources during blocking, and
+        it will block until one of the two following conditions are met:
+
+        1) The server is stopped or terminated;
+        2) A timeout occurs if timeout is not `None`.
+
+        The timeout argument works in the same way as `threading.Event.wait()`.
+        https://docs.python.org/3/library/threading.html#threading.Event.wait
+
+        Args:
+          timeout: A floating point number specifying a timeout for the
+            operation in seconds.
+
+        Returns:
+          A bool indicates if the operation times out.
+        """
+
+
+class ServicerContext(Generic[RequestType, ResponseType], abc.ABC):
+    """A context object passed to method implementations."""
+
+    @abc.abstractmethod
+    async def read(self) -> RequestType:
+        """Reads one message from the RPC.
+
+        Only one read operation is allowed simultaneously.
+
+        Returns:
+          A response message of the RPC.
+
+        Raises:
+          An RpcError exception if the read failed.
+        """
+
+    @abc.abstractmethod
+    async def write(self, message: ResponseType) -> None:
+        """Writes one message to the RPC.
+
+        Only one write operation is allowed simultaneously.
+
+        Raises:
+          An RpcError exception if the write failed.
+        """
+
+    @abc.abstractmethod
+    async def send_initial_metadata(self, initial_metadata: Metadata) -> None:
+        """Sends the initial metadata value to the client.
+
+        This method need not be called by implementations if they have no
+        metadata to add to what the gRPC runtime will transmit.
+
+        Args:
+          initial_metadata: The initial :term:`metadata`.
+        """
+
+    @abc.abstractmethod
+    async def abort(self, code: grpc.StatusCode, details: str,
+                    trailing_metadata: Metadata) -> None:
+        """Raises an exception to terminate the RPC with a non-OK status.
+
+        The code and details passed as arguments will supercede any existing
+        ones.
+
+        Args:
+          code: A StatusCode object to be sent to the client.
+            It must not be StatusCode.OK.
+          details: A UTF-8-encodable string to be sent to the client upon
+            termination of the RPC.
+          trailing_metadata: A sequence of tuple represents the trailing
+            :term:`metadata`.
+
+        Raises:
+          Exception: An exception is always raised to signal the abortion the
+            RPC to the gRPC runtime.
+        """
+
+    @abc.abstractmethod
+    async def set_trailing_metadata(self, trailing_metadata: Metadata) -> None:
+        """Sends the trailing metadata for the RPC.
+
+        This method need not be called by implementations if they have no
+        metadata to add to what the gRPC runtime will transmit.
+
+        Args:
+          trailing_metadata: The trailing :term:`metadata`.
+        """
+
+    @abc.abstractmethod
+    def invocation_metadata(self) -> Optional[Metadata]:
+        """Accesses the metadata from the sent by the client.
+
+        Returns:
+          The invocation :term:`metadata`.
+        """
+
+    @abc.abstractmethod
+    def set_code(self, code: grpc.StatusCode) -> None:
+        """Sets the value to be used as status code upon RPC completion.
+
+        This method need not be called by method implementations if they wish
+        the gRPC runtime to determine the status code of the RPC.
+
+        Args:
+          code: A StatusCode object to be sent to the client.
+        """
+
+    @abc.abstractmethod
+    def set_details(self, details: str) -> None:
+        """Sets the value to be used the as detail string upon RPC completion.
+
+        This method need not be called by method implementations if they have
+        no details to transmit.
+
+        Args:
+          details: A UTF-8-encodable string to be sent to the client upon
+            termination of the RPC.
+        """
+
+    @abc.abstractmethod
+    def set_compression(self, compression: grpc.Compression) -> None:
+        """Set the compression algorithm to be used for the entire call.
+
+        This is an EXPERIMENTAL method.
+
+        Args:
+          compression: An element of grpc.compression, e.g.
+            grpc.compression.Gzip.
+        """
+
+    @abc.abstractmethod
+    def disable_next_message_compression(self) -> None:
+        """Disables compression for the next response message.
+
+        This is an EXPERIMENTAL method.
+
+        This method will override any compression configuration set during
+        server creation or set on the call.
+        """
+
+    @abc.abstractmethod
+    def peer(self) -> str:
+        """Identifies the peer that invoked the RPC being serviced.
+
+        Returns:
+          A string identifying the peer that invoked the RPC being serviced.
+          The string format is determined by gRPC runtime.
+        """
+
+    @abc.abstractmethod
+    def peer_identities(self) -> Optional[Iterable[bytes]]:
+        """Gets one or more peer identity(s).
+
+        Equivalent to
+        servicer_context.auth_context().get(servicer_context.peer_identity_key())
+
+        Returns:
+          An iterable of the identities, or None if the call is not
+          authenticated. Each identity is returned as a raw bytes type.
+        """
+
+    @abc.abstractmethod
+    def peer_identity_key(self) -> Optional[str]:
+        """The auth property used to identify the peer.
+
+        For example, "x509_common_name" or "x509_subject_alternative_name" are
+        used to identify an SSL peer.
+
+        Returns:
+          The auth property (string) that indicates the
+          peer identity, or None if the call is not authenticated.
+        """
+
+    @abc.abstractmethod
+    def auth_context(self) -> Mapping[str, Iterable[bytes]]:
+        """Gets the auth context for the call.
+
+        Returns:
+          A map of strings to an iterable of bytes for each auth property.
+        """
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_call.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_call.py
index 975f7c55a1..ba229f35c3 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_call.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_call.py
@@ -1,629 +1,629 @@
-# Copyright 2019 gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Invocation-side implementation of gRPC Asyncio Python.""" 
- 
-import asyncio 
-import enum 
-import inspect 
-import logging 
-from functools import partial 
-from typing import AsyncIterable, Optional, Tuple 
- 
-import grpc 
-from grpc import _common 
-from grpc._cython import cygrpc 
- 
-from . import _base_call 
-from ._metadata import Metadata 
-from ._typing import (DeserializingFunction, DoneCallbackType, MetadatumType, 
-                      RequestIterableType, RequestType, ResponseType, 
-                      SerializingFunction) 
- 
-__all__ = 'AioRpcError', 'Call', 'UnaryUnaryCall', 'UnaryStreamCall' 
- 
-_LOCAL_CANCELLATION_DETAILS = 'Locally cancelled by application!' 
-_GC_CANCELLATION_DETAILS = 'Cancelled upon garbage collection!' 
-_RPC_ALREADY_FINISHED_DETAILS = 'RPC already finished.' 
-_RPC_HALF_CLOSED_DETAILS = 'RPC is half closed after calling "done_writing".' 
-_API_STYLE_ERROR = 'The iterator and read/write APIs may not be mixed on a single RPC.' 
- 
-_OK_CALL_REPRESENTATION = ('<{} of RPC that terminated with:\n' 
-                           '\tstatus = {}\n' 
-                           '\tdetails = "{}"\n' 
-                           '>') 
- 
-_NON_OK_CALL_REPRESENTATION = ('<{} of RPC that terminated with:\n' 
-                               '\tstatus = {}\n' 
-                               '\tdetails = "{}"\n' 
-                               '\tdebug_error_string = "{}"\n' 
-                               '>') 
- 
-_LOGGER = logging.getLogger(__name__) 
- 
- 
-class AioRpcError(grpc.RpcError): 
-    """An implementation of RpcError to be used by the asynchronous API. 
- 
-    Raised RpcError is a snapshot of the final status of the RPC, values are 
-    determined. Hence, its methods no longer needs to be coroutines. 
-    """ 
- 
-    _code: grpc.StatusCode 
-    _details: Optional[str] 
-    _initial_metadata: Optional[Metadata] 
-    _trailing_metadata: Optional[Metadata] 
-    _debug_error_string: Optional[str] 
- 
-    def __init__(self, 
-                 code: grpc.StatusCode, 
-                 initial_metadata: Metadata, 
-                 trailing_metadata: Metadata, 
-                 details: Optional[str] = None, 
-                 debug_error_string: Optional[str] = None) -> None: 
-        """Constructor. 
- 
-        Args: 
-          code: The status code with which the RPC has been finalized. 
-          details: Optional details explaining the reason of the error. 
-          initial_metadata: Optional initial metadata that could be sent by the 
-            Server. 
-          trailing_metadata: Optional metadata that could be sent by the Server. 
-        """ 
- 
-        super().__init__(self) 
-        self._code = code 
-        self._details = details 
-        self._initial_metadata = initial_metadata 
-        self._trailing_metadata = trailing_metadata 
-        self._debug_error_string = debug_error_string 
- 
-    def code(self) -> grpc.StatusCode: 
-        """Accesses the status code sent by the server. 
- 
-        Returns: 
-          The `grpc.StatusCode` status code. 
-        """ 
-        return self._code 
- 
-    def details(self) -> Optional[str]: 
-        """Accesses the details sent by the server. 
- 
-        Returns: 
-          The description of the error. 
-        """ 
-        return self._details 
- 
-    def initial_metadata(self) -> Metadata: 
-        """Accesses the initial metadata sent by the server. 
- 
-        Returns: 
-          The initial metadata received. 
-        """ 
-        return self._initial_metadata 
- 
-    def trailing_metadata(self) -> Metadata: 
-        """Accesses the trailing metadata sent by the server. 
- 
-        Returns: 
-          The trailing metadata received. 
-        """ 
-        return self._trailing_metadata 
- 
-    def debug_error_string(self) -> str: 
-        """Accesses the debug error string sent by the server. 
- 
-        Returns: 
-          The debug error string received. 
-        """ 
-        return self._debug_error_string 
- 
-    def _repr(self) -> str: 
-        """Assembles the error string for the RPC error.""" 
-        return _NON_OK_CALL_REPRESENTATION.format(self.__class__.__name__, 
-                                                  self._code, self._details, 
-                                                  self._debug_error_string) 
- 
-    def __repr__(self) -> str: 
-        return self._repr() 
- 
-    def __str__(self) -> str: 
-        return self._repr() 
- 
- 
-def _create_rpc_error(initial_metadata: Metadata, 
-                      status: cygrpc.AioRpcStatus) -> AioRpcError: 
-    return AioRpcError( 
-        _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[status.code()], 
-        Metadata.from_tuple(initial_metadata), 
-        Metadata.from_tuple(status.trailing_metadata()), 
-        details=status.details(), 
-        debug_error_string=status.debug_error_string(), 
-    ) 
- 
- 
-class Call: 
-    """Base implementation of client RPC Call object. 
- 
-    Implements logic around final status, metadata and cancellation. 
-    """ 
-    _loop: asyncio.AbstractEventLoop 
-    _code: grpc.StatusCode 
-    _cython_call: cygrpc._AioCall 
-    _metadata: Tuple[MetadatumType] 
-    _request_serializer: SerializingFunction 
-    _response_deserializer: DeserializingFunction 
- 
-    def __init__(self, cython_call: cygrpc._AioCall, metadata: Metadata, 
-                 request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        self._loop = loop 
-        self._cython_call = cython_call 
-        self._metadata = tuple(metadata) 
-        self._request_serializer = request_serializer 
-        self._response_deserializer = response_deserializer 
- 
-    def __del__(self) -> None: 
-        # The '_cython_call' object might be destructed before Call object 
-        if hasattr(self, '_cython_call'): 
-            if not self._cython_call.done(): 
-                self._cancel(_GC_CANCELLATION_DETAILS) 
- 
-    def cancelled(self) -> bool: 
-        return self._cython_call.cancelled() 
- 
-    def _cancel(self, details: str) -> bool: 
-        """Forwards the application cancellation reasoning.""" 
-        if not self._cython_call.done(): 
-            self._cython_call.cancel(details) 
-            return True 
-        else: 
-            return False 
- 
-    def cancel(self) -> bool: 
-        return self._cancel(_LOCAL_CANCELLATION_DETAILS) 
- 
-    def done(self) -> bool: 
-        return self._cython_call.done() 
- 
-    def add_done_callback(self, callback: DoneCallbackType) -> None: 
-        cb = partial(callback, self) 
-        self._cython_call.add_done_callback(cb) 
- 
-    def time_remaining(self) -> Optional[float]: 
-        return self._cython_call.time_remaining() 
- 
-    async def initial_metadata(self) -> Metadata: 
-        raw_metadata_tuple = await self._cython_call.initial_metadata() 
-        return Metadata.from_tuple(raw_metadata_tuple) 
- 
-    async def trailing_metadata(self) -> Metadata: 
-        raw_metadata_tuple = (await 
-                              self._cython_call.status()).trailing_metadata() 
-        return Metadata.from_tuple(raw_metadata_tuple) 
- 
-    async def code(self) -> grpc.StatusCode: 
-        cygrpc_code = (await self._cython_call.status()).code() 
-        return _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[cygrpc_code] 
- 
-    async def details(self) -> str: 
-        return (await self._cython_call.status()).details() 
- 
-    async def debug_error_string(self) -> str: 
-        return (await self._cython_call.status()).debug_error_string() 
- 
-    async def _raise_for_status(self) -> None: 
-        if self._cython_call.is_locally_cancelled(): 
-            raise asyncio.CancelledError() 
-        code = await self.code() 
-        if code != grpc.StatusCode.OK: 
-            raise _create_rpc_error(await self.initial_metadata(), await 
-                                    self._cython_call.status()) 
- 
-    def _repr(self) -> str: 
-        return repr(self._cython_call) 
- 
-    def __repr__(self) -> str: 
-        return self._repr() 
- 
-    def __str__(self) -> str: 
-        return self._repr() 
- 
- 
-class _APIStyle(enum.IntEnum): 
-    UNKNOWN = 0 
-    ASYNC_GENERATOR = 1 
-    READER_WRITER = 2 
- 
- 
-class _UnaryResponseMixin(Call): 
-    _call_response: asyncio.Task 
- 
-    def _init_unary_response_mixin(self, response_task: asyncio.Task): 
-        self._call_response = response_task 
- 
-    def cancel(self) -> bool: 
-        if super().cancel(): 
-            self._call_response.cancel() 
-            return True 
-        else: 
-            return False 
- 
-    def __await__(self) -> ResponseType: 
-        """Wait till the ongoing RPC request finishes.""" 
-        try: 
-            response = yield from self._call_response 
-        except asyncio.CancelledError: 
-            # Even if we caught all other CancelledError, there is still 
-            # this corner case. If the application cancels immediately after 
-            # the Call object is created, we will observe this 
-            # `CancelledError`. 
-            if not self.cancelled(): 
-                self.cancel() 
-            raise 
- 
-        # NOTE(lidiz) If we raise RpcError in the task, and users doesn't 
-        # 'await' on it. AsyncIO will log 'Task exception was never retrieved'. 
-        # Instead, if we move the exception raising here, the spam stops. 
-        # Unfortunately, there can only be one 'yield from' in '__await__'. So, 
-        # we need to access the private instance variable. 
-        if response is cygrpc.EOF: 
-            if self._cython_call.is_locally_cancelled(): 
-                raise asyncio.CancelledError() 
-            else: 
-                raise _create_rpc_error(self._cython_call._initial_metadata, 
-                                        self._cython_call._status) 
-        else: 
-            return response 
- 
- 
-class _StreamResponseMixin(Call): 
-    _message_aiter: AsyncIterable[ResponseType] 
-    _preparation: asyncio.Task 
-    _response_style: _APIStyle 
- 
-    def _init_stream_response_mixin(self, preparation: asyncio.Task): 
-        self._message_aiter = None 
-        self._preparation = preparation 
-        self._response_style = _APIStyle.UNKNOWN 
- 
-    def _update_response_style(self, style: _APIStyle): 
-        if self._response_style is _APIStyle.UNKNOWN: 
-            self._response_style = style 
-        elif self._response_style is not style: 
-            raise cygrpc.UsageError(_API_STYLE_ERROR) 
- 
-    def cancel(self) -> bool: 
-        if super().cancel(): 
-            self._preparation.cancel() 
-            return True 
-        else: 
-            return False 
- 
-    async def _fetch_stream_responses(self) -> ResponseType: 
-        message = await self._read() 
-        while message is not cygrpc.EOF: 
-            yield message 
-            message = await self._read() 
- 
-        # If the read operation failed, Core should explain why. 
-        await self._raise_for_status() 
- 
-    def __aiter__(self) -> AsyncIterable[ResponseType]: 
-        self._update_response_style(_APIStyle.ASYNC_GENERATOR) 
-        if self._message_aiter is None: 
-            self._message_aiter = self._fetch_stream_responses() 
-        return self._message_aiter 
- 
-    async def _read(self) -> ResponseType: 
-        # Wait for the request being sent 
-        await self._preparation 
- 
-        # Reads response message from Core 
-        try: 
-            raw_response = await self._cython_call.receive_serialized_message() 
-        except asyncio.CancelledError: 
-            if not self.cancelled(): 
-                self.cancel() 
-            await self._raise_for_status() 
- 
-        if raw_response is cygrpc.EOF: 
-            return cygrpc.EOF 
-        else: 
-            return _common.deserialize(raw_response, 
-                                       self._response_deserializer) 
- 
-    async def read(self) -> ResponseType: 
-        if self.done(): 
-            await self._raise_for_status() 
-            return cygrpc.EOF 
-        self._update_response_style(_APIStyle.READER_WRITER) 
- 
-        response_message = await self._read() 
- 
-        if response_message is cygrpc.EOF: 
-            # If the read operation failed, Core should explain why. 
-            await self._raise_for_status() 
-        return response_message 
- 
- 
-class _StreamRequestMixin(Call): 
-    _metadata_sent: asyncio.Event 
-    _done_writing_flag: bool 
-    _async_request_poller: Optional[asyncio.Task] 
-    _request_style: _APIStyle 
- 
-    def _init_stream_request_mixin( 
-            self, request_iterator: Optional[RequestIterableType]): 
-        self._metadata_sent = asyncio.Event(loop=self._loop) 
-        self._done_writing_flag = False 
- 
-        # If user passes in an async iterator, create a consumer Task. 
-        if request_iterator is not None: 
-            self._async_request_poller = self._loop.create_task( 
-                self._consume_request_iterator(request_iterator)) 
-            self._request_style = _APIStyle.ASYNC_GENERATOR 
-        else: 
-            self._async_request_poller = None 
-            self._request_style = _APIStyle.READER_WRITER 
- 
-    def _raise_for_different_style(self, style: _APIStyle): 
-        if self._request_style is not style: 
-            raise cygrpc.UsageError(_API_STYLE_ERROR) 
- 
-    def cancel(self) -> bool: 
-        if super().cancel(): 
-            if self._async_request_poller is not None: 
-                self._async_request_poller.cancel() 
-            return True 
-        else: 
-            return False 
- 
-    def _metadata_sent_observer(self): 
-        self._metadata_sent.set() 
- 
-    async def _consume_request_iterator(self, 
-                                        request_iterator: RequestIterableType 
-                                       ) -> None: 
-        try: 
-            if inspect.isasyncgen(request_iterator) or hasattr( 
-                    request_iterator, '__aiter__'): 
-                async for request in request_iterator: 
-                    await self._write(request) 
-            else: 
-                for request in request_iterator: 
-                    await self._write(request) 
- 
-            await self._done_writing() 
-        except AioRpcError as rpc_error: 
-            # Rpc status should be exposed through other API. Exceptions raised 
-            # within this Task won't be retrieved by another coroutine. It's 
-            # better to suppress the error than spamming users' screen. 
-            _LOGGER.debug('Exception while consuming the request_iterator: %s', 
-                          rpc_error) 
- 
-    async def _write(self, request: RequestType) -> None: 
-        if self.done(): 
-            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS) 
-        if self._done_writing_flag: 
-            raise asyncio.InvalidStateError(_RPC_HALF_CLOSED_DETAILS) 
-        if not self._metadata_sent.is_set(): 
-            await self._metadata_sent.wait() 
-            if self.done(): 
-                await self._raise_for_status() 
- 
-        serialized_request = _common.serialize(request, 
-                                               self._request_serializer) 
-        try: 
-            await self._cython_call.send_serialized_message(serialized_request) 
-        except asyncio.CancelledError: 
-            if not self.cancelled(): 
-                self.cancel() 
-            await self._raise_for_status() 
- 
-    async def _done_writing(self) -> None: 
-        if self.done(): 
-            # If the RPC is finished, do nothing. 
-            return 
-        if not self._done_writing_flag: 
-            # If the done writing is not sent before, try to send it. 
-            self._done_writing_flag = True 
-            try: 
-                await self._cython_call.send_receive_close() 
-            except asyncio.CancelledError: 
-                if not self.cancelled(): 
-                    self.cancel() 
-                await self._raise_for_status() 
- 
-    async def write(self, request: RequestType) -> None: 
-        self._raise_for_different_style(_APIStyle.READER_WRITER) 
-        await self._write(request) 
- 
-    async def done_writing(self) -> None: 
-        """Signal peer that client is done writing. 
- 
-        This method is idempotent. 
-        """ 
-        self._raise_for_different_style(_APIStyle.READER_WRITER) 
-        await self._done_writing() 
- 
-    async def wait_for_connection(self) -> None: 
-        await self._metadata_sent.wait() 
-        if self.done(): 
-            await self._raise_for_status() 
- 
- 
-class UnaryUnaryCall(_UnaryResponseMixin, Call, _base_call.UnaryUnaryCall): 
-    """Object for managing unary-unary RPC calls. 
- 
-    Returned when an instance of `UnaryUnaryMultiCallable` object is called. 
-    """ 
-    _request: RequestType 
-    _invocation_task: asyncio.Task 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__(self, request: RequestType, deadline: Optional[float], 
-                 metadata: Metadata, 
-                 credentials: Optional[grpc.CallCredentials], 
-                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel, 
-                 method: bytes, request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        super().__init__( 
-            channel.call(method, deadline, credentials, wait_for_ready), 
-            metadata, request_serializer, response_deserializer, loop) 
-        self._request = request 
-        self._invocation_task = loop.create_task(self._invoke()) 
-        self._init_unary_response_mixin(self._invocation_task) 
- 
-    async def _invoke(self) -> ResponseType: 
-        serialized_request = _common.serialize(self._request, 
-                                               self._request_serializer) 
- 
-        # NOTE(lidiz) asyncio.CancelledError is not a good transport for status, 
-        # because the asyncio.Task class do not cache the exception object. 
-        # https://github.com/python/cpython/blob/edad4d89e357c92f70c0324b937845d652b20afd/Lib/asyncio/tasks.py#L785 
-        try: 
-            serialized_response = await self._cython_call.unary_unary( 
-                serialized_request, self._metadata) 
-        except asyncio.CancelledError: 
-            if not self.cancelled(): 
-                self.cancel() 
- 
-        if self._cython_call.is_ok(): 
-            return _common.deserialize(serialized_response, 
-                                       self._response_deserializer) 
-        else: 
-            return cygrpc.EOF 
- 
-    async def wait_for_connection(self) -> None: 
-        await self._invocation_task 
-        if self.done(): 
-            await self._raise_for_status() 
- 
- 
-class UnaryStreamCall(_StreamResponseMixin, Call, _base_call.UnaryStreamCall): 
-    """Object for managing unary-stream RPC calls. 
- 
-    Returned when an instance of `UnaryStreamMultiCallable` object is called. 
-    """ 
-    _request: RequestType 
-    _send_unary_request_task: asyncio.Task 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__(self, request: RequestType, deadline: Optional[float], 
-                 metadata: Metadata, 
-                 credentials: Optional[grpc.CallCredentials], 
-                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel, 
-                 method: bytes, request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        super().__init__( 
-            channel.call(method, deadline, credentials, wait_for_ready), 
-            metadata, request_serializer, response_deserializer, loop) 
-        self._request = request 
-        self._send_unary_request_task = loop.create_task( 
-            self._send_unary_request()) 
-        self._init_stream_response_mixin(self._send_unary_request_task) 
- 
-    async def _send_unary_request(self) -> ResponseType: 
-        serialized_request = _common.serialize(self._request, 
-                                               self._request_serializer) 
-        try: 
-            await self._cython_call.initiate_unary_stream( 
-                serialized_request, self._metadata) 
-        except asyncio.CancelledError: 
-            if not self.cancelled(): 
-                self.cancel() 
-            raise 
- 
-    async def wait_for_connection(self) -> None: 
-        await self._send_unary_request_task 
-        if self.done(): 
-            await self._raise_for_status() 
- 
- 
-class StreamUnaryCall(_StreamRequestMixin, _UnaryResponseMixin, Call, 
-                      _base_call.StreamUnaryCall): 
-    """Object for managing stream-unary RPC calls. 
- 
-    Returned when an instance of `StreamUnaryMultiCallable` object is called. 
-    """ 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__(self, request_iterator: Optional[RequestIterableType], 
-                 deadline: Optional[float], metadata: Metadata, 
-                 credentials: Optional[grpc.CallCredentials], 
-                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel, 
-                 method: bytes, request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        super().__init__( 
-            channel.call(method, deadline, credentials, wait_for_ready), 
-            metadata, request_serializer, response_deserializer, loop) 
- 
-        self._init_stream_request_mixin(request_iterator) 
-        self._init_unary_response_mixin(loop.create_task(self._conduct_rpc())) 
- 
-    async def _conduct_rpc(self) -> ResponseType: 
-        try: 
-            serialized_response = await self._cython_call.stream_unary( 
-                self._metadata, self._metadata_sent_observer) 
-        except asyncio.CancelledError: 
-            if not self.cancelled(): 
-                self.cancel() 
- 
-        if self._cython_call.is_ok(): 
-            return _common.deserialize(serialized_response, 
-                                       self._response_deserializer) 
-        else: 
-            return cygrpc.EOF 
- 
- 
-class StreamStreamCall(_StreamRequestMixin, _StreamResponseMixin, Call, 
-                       _base_call.StreamStreamCall): 
-    """Object for managing stream-stream RPC calls. 
- 
-    Returned when an instance of `StreamStreamMultiCallable` object is called. 
-    """ 
-    _initializer: asyncio.Task 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__(self, request_iterator: Optional[RequestIterableType], 
-                 deadline: Optional[float], metadata: Metadata, 
-                 credentials: Optional[grpc.CallCredentials], 
-                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel, 
-                 method: bytes, request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        super().__init__( 
-            channel.call(method, deadline, credentials, wait_for_ready), 
-            metadata, request_serializer, response_deserializer, loop) 
-        self._initializer = self._loop.create_task(self._prepare_rpc()) 
-        self._init_stream_request_mixin(request_iterator) 
-        self._init_stream_response_mixin(self._initializer) 
- 
-    async def _prepare_rpc(self): 
-        """This method prepares the RPC for receiving/sending messages. 
- 
-        All other operations around the stream should only happen after the 
-        completion of this method. 
-        """ 
-        try: 
-            await self._cython_call.initiate_stream_stream( 
-                self._metadata, self._metadata_sent_observer) 
-        except asyncio.CancelledError: 
-            if not self.cancelled(): 
-                self.cancel() 
-            # No need to raise RpcError here, because no one will `await` this task. 
+# Copyright 2019 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Invocation-side implementation of gRPC Asyncio Python."""
+
+import asyncio
+import enum
+import inspect
+import logging
+from functools import partial
+from typing import AsyncIterable, Optional, Tuple
+
+import grpc
+from grpc import _common
+from grpc._cython import cygrpc
+
+from . import _base_call
+from ._metadata import Metadata
+from ._typing import (DeserializingFunction, DoneCallbackType, MetadatumType,
+                      RequestIterableType, RequestType, ResponseType,
+                      SerializingFunction)
+
+__all__ = 'AioRpcError', 'Call', 'UnaryUnaryCall', 'UnaryStreamCall'
+
+_LOCAL_CANCELLATION_DETAILS = 'Locally cancelled by application!'
+_GC_CANCELLATION_DETAILS = 'Cancelled upon garbage collection!'
+_RPC_ALREADY_FINISHED_DETAILS = 'RPC already finished.'
+_RPC_HALF_CLOSED_DETAILS = 'RPC is half closed after calling "done_writing".'
+_API_STYLE_ERROR = 'The iterator and read/write APIs may not be mixed on a single RPC.'
+
+_OK_CALL_REPRESENTATION = ('<{} of RPC that terminated with:\n'
+                           '\tstatus = {}\n'
+                           '\tdetails = "{}"\n'
+                           '>')
+
+_NON_OK_CALL_REPRESENTATION = ('<{} of RPC that terminated with:\n'
+                               '\tstatus = {}\n'
+                               '\tdetails = "{}"\n'
+                               '\tdebug_error_string = "{}"\n'
+                               '>')
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AioRpcError(grpc.RpcError):
+    """An implementation of RpcError to be used by the asynchronous API.
+
+    Raised RpcError is a snapshot of the final status of the RPC, values are
+    determined. Hence, its methods no longer needs to be coroutines.
+    """
+
+    _code: grpc.StatusCode
+    _details: Optional[str]
+    _initial_metadata: Optional[Metadata]
+    _trailing_metadata: Optional[Metadata]
+    _debug_error_string: Optional[str]
+
+    def __init__(self,
+                 code: grpc.StatusCode,
+                 initial_metadata: Metadata,
+                 trailing_metadata: Metadata,
+                 details: Optional[str] = None,
+                 debug_error_string: Optional[str] = None) -> None:
+        """Constructor.
+
+        Args:
+          code: The status code with which the RPC has been finalized.
+          details: Optional details explaining the reason of the error.
+          initial_metadata: Optional initial metadata that could be sent by the
+            Server.
+          trailing_metadata: Optional metadata that could be sent by the Server.
+        """
+
+        super().__init__(self)
+        self._code = code
+        self._details = details
+        self._initial_metadata = initial_metadata
+        self._trailing_metadata = trailing_metadata
+        self._debug_error_string = debug_error_string
+
+    def code(self) -> grpc.StatusCode:
+        """Accesses the status code sent by the server.
+
+        Returns:
+          The `grpc.StatusCode` status code.
+        """
+        return self._code
+
+    def details(self) -> Optional[str]:
+        """Accesses the details sent by the server.
+
+        Returns:
+          The description of the error.
+        """
+        return self._details
+
+    def initial_metadata(self) -> Metadata:
+        """Accesses the initial metadata sent by the server.
+
+        Returns:
+          The initial metadata received.
+        """
+        return self._initial_metadata
+
+    def trailing_metadata(self) -> Metadata:
+        """Accesses the trailing metadata sent by the server.
+
+        Returns:
+          The trailing metadata received.
+        """
+        return self._trailing_metadata
+
+    def debug_error_string(self) -> str:
+        """Accesses the debug error string sent by the server.
+
+        Returns:
+          The debug error string received.
+        """
+        return self._debug_error_string
+
+    def _repr(self) -> str:
+        """Assembles the error string for the RPC error."""
+        return _NON_OK_CALL_REPRESENTATION.format(self.__class__.__name__,
+                                                  self._code, self._details,
+                                                  self._debug_error_string)
+
+    def __repr__(self) -> str:
+        return self._repr()
+
+    def __str__(self) -> str:
+        return self._repr()
+
+
+def _create_rpc_error(initial_metadata: Metadata,
+                      status: cygrpc.AioRpcStatus) -> AioRpcError:
+    return AioRpcError(
+        _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[status.code()],
+        Metadata.from_tuple(initial_metadata),
+        Metadata.from_tuple(status.trailing_metadata()),
+        details=status.details(),
+        debug_error_string=status.debug_error_string(),
+    )
+
+
+class Call:
+    """Base implementation of client RPC Call object.
+
+    Implements logic around final status, metadata and cancellation.
+    """
+    _loop: asyncio.AbstractEventLoop
+    _code: grpc.StatusCode
+    _cython_call: cygrpc._AioCall
+    _metadata: Tuple[MetadatumType]
+    _request_serializer: SerializingFunction
+    _response_deserializer: DeserializingFunction
+
+    def __init__(self, cython_call: cygrpc._AioCall, metadata: Metadata,
+                 request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._cython_call = cython_call
+        self._metadata = tuple(metadata)
+        self._request_serializer = request_serializer
+        self._response_deserializer = response_deserializer
+
+    def __del__(self) -> None:
+        # The '_cython_call' object might be destructed before Call object
+        if hasattr(self, '_cython_call'):
+            if not self._cython_call.done():
+                self._cancel(_GC_CANCELLATION_DETAILS)
+
+    def cancelled(self) -> bool:
+        return self._cython_call.cancelled()
+
+    def _cancel(self, details: str) -> bool:
+        """Forwards the application cancellation reasoning."""
+        if not self._cython_call.done():
+            self._cython_call.cancel(details)
+            return True
+        else:
+            return False
+
+    def cancel(self) -> bool:
+        return self._cancel(_LOCAL_CANCELLATION_DETAILS)
+
+    def done(self) -> bool:
+        return self._cython_call.done()
+
+    def add_done_callback(self, callback: DoneCallbackType) -> None:
+        cb = partial(callback, self)
+        self._cython_call.add_done_callback(cb)
+
+    def time_remaining(self) -> Optional[float]:
+        return self._cython_call.time_remaining()
+
+    async def initial_metadata(self) -> Metadata:
+        raw_metadata_tuple = await self._cython_call.initial_metadata()
+        return Metadata.from_tuple(raw_metadata_tuple)
+
+    async def trailing_metadata(self) -> Metadata:
+        raw_metadata_tuple = (await
+                              self._cython_call.status()).trailing_metadata()
+        return Metadata.from_tuple(raw_metadata_tuple)
+
+    async def code(self) -> grpc.StatusCode:
+        cygrpc_code = (await self._cython_call.status()).code()
+        return _common.CYGRPC_STATUS_CODE_TO_STATUS_CODE[cygrpc_code]
+
+    async def details(self) -> str:
+        return (await self._cython_call.status()).details()
+
+    async def debug_error_string(self) -> str:
+        return (await self._cython_call.status()).debug_error_string()
+
+    async def _raise_for_status(self) -> None:
+        if self._cython_call.is_locally_cancelled():
+            raise asyncio.CancelledError()
+        code = await self.code()
+        if code != grpc.StatusCode.OK:
+            raise _create_rpc_error(await self.initial_metadata(), await
+                                    self._cython_call.status())
+
+    def _repr(self) -> str:
+        return repr(self._cython_call)
+
+    def __repr__(self) -> str:
+        return self._repr()
+
+    def __str__(self) -> str:
+        return self._repr()
+
+
+class _APIStyle(enum.IntEnum):
+    UNKNOWN = 0
+    ASYNC_GENERATOR = 1
+    READER_WRITER = 2
+
+
+class _UnaryResponseMixin(Call):
+    _call_response: asyncio.Task
+
+    def _init_unary_response_mixin(self, response_task: asyncio.Task):
+        self._call_response = response_task
+
+    def cancel(self) -> bool:
+        if super().cancel():
+            self._call_response.cancel()
+            return True
+        else:
+            return False
+
+    def __await__(self) -> ResponseType:
+        """Wait till the ongoing RPC request finishes."""
+        try:
+            response = yield from self._call_response
+        except asyncio.CancelledError:
+            # Even if we caught all other CancelledError, there is still
+            # this corner case. If the application cancels immediately after
+            # the Call object is created, we will observe this
+            # `CancelledError`.
+            if not self.cancelled():
+                self.cancel()
+            raise
+
+        # NOTE(lidiz) If we raise RpcError in the task, and users doesn't
+        # 'await' on it. AsyncIO will log 'Task exception was never retrieved'.
+        # Instead, if we move the exception raising here, the spam stops.
+        # Unfortunately, there can only be one 'yield from' in '__await__'. So,
+        # we need to access the private instance variable.
+        if response is cygrpc.EOF:
+            if self._cython_call.is_locally_cancelled():
+                raise asyncio.CancelledError()
+            else:
+                raise _create_rpc_error(self._cython_call._initial_metadata,
+                                        self._cython_call._status)
+        else:
+            return response
+
+
+class _StreamResponseMixin(Call):
+    _message_aiter: AsyncIterable[ResponseType]
+    _preparation: asyncio.Task
+    _response_style: _APIStyle
+
+    def _init_stream_response_mixin(self, preparation: asyncio.Task):
+        self._message_aiter = None
+        self._preparation = preparation
+        self._response_style = _APIStyle.UNKNOWN
+
+    def _update_response_style(self, style: _APIStyle):
+        if self._response_style is _APIStyle.UNKNOWN:
+            self._response_style = style
+        elif self._response_style is not style:
+            raise cygrpc.UsageError(_API_STYLE_ERROR)
+
+    def cancel(self) -> bool:
+        if super().cancel():
+            self._preparation.cancel()
+            return True
+        else:
+            return False
+
+    async def _fetch_stream_responses(self) -> ResponseType:
+        message = await self._read()
+        while message is not cygrpc.EOF:
+            yield message
+            message = await self._read()
+
+        # If the read operation failed, Core should explain why.
+        await self._raise_for_status()
+
+    def __aiter__(self) -> AsyncIterable[ResponseType]:
+        self._update_response_style(_APIStyle.ASYNC_GENERATOR)
+        if self._message_aiter is None:
+            self._message_aiter = self._fetch_stream_responses()
+        return self._message_aiter
+
+    async def _read(self) -> ResponseType:
+        # Wait for the request being sent
+        await self._preparation
+
+        # Reads response message from Core
+        try:
+            raw_response = await self._cython_call.receive_serialized_message()
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            await self._raise_for_status()
+
+        if raw_response is cygrpc.EOF:
+            return cygrpc.EOF
+        else:
+            return _common.deserialize(raw_response,
+                                       self._response_deserializer)
+
+    async def read(self) -> ResponseType:
+        if self.done():
+            await self._raise_for_status()
+            return cygrpc.EOF
+        self._update_response_style(_APIStyle.READER_WRITER)
+
+        response_message = await self._read()
+
+        if response_message is cygrpc.EOF:
+            # If the read operation failed, Core should explain why.
+            await self._raise_for_status()
+        return response_message
+
+
+class _StreamRequestMixin(Call):
+    _metadata_sent: asyncio.Event
+    _done_writing_flag: bool
+    _async_request_poller: Optional[asyncio.Task]
+    _request_style: _APIStyle
+
+    def _init_stream_request_mixin(
+            self, request_iterator: Optional[RequestIterableType]):
+        self._metadata_sent = asyncio.Event(loop=self._loop)
+        self._done_writing_flag = False
+
+        # If user passes in an async iterator, create a consumer Task.
+        if request_iterator is not None:
+            self._async_request_poller = self._loop.create_task(
+                self._consume_request_iterator(request_iterator))
+            self._request_style = _APIStyle.ASYNC_GENERATOR
+        else:
+            self._async_request_poller = None
+            self._request_style = _APIStyle.READER_WRITER
+
+    def _raise_for_different_style(self, style: _APIStyle):
+        if self._request_style is not style:
+            raise cygrpc.UsageError(_API_STYLE_ERROR)
+
+    def cancel(self) -> bool:
+        if super().cancel():
+            if self._async_request_poller is not None:
+                self._async_request_poller.cancel()
+            return True
+        else:
+            return False
+
+    def _metadata_sent_observer(self):
+        self._metadata_sent.set()
+
+    async def _consume_request_iterator(self,
+                                        request_iterator: RequestIterableType
+                                       ) -> None:
+        try:
+            if inspect.isasyncgen(request_iterator) or hasattr(
+                    request_iterator, '__aiter__'):
+                async for request in request_iterator:
+                    await self._write(request)
+            else:
+                for request in request_iterator:
+                    await self._write(request)
+
+            await self._done_writing()
+        except AioRpcError as rpc_error:
+            # Rpc status should be exposed through other API. Exceptions raised
+            # within this Task won't be retrieved by another coroutine. It's
+            # better to suppress the error than spamming users' screen.
+            _LOGGER.debug('Exception while consuming the request_iterator: %s',
+                          rpc_error)
+
+    async def _write(self, request: RequestType) -> None:
+        if self.done():
+            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
+        if self._done_writing_flag:
+            raise asyncio.InvalidStateError(_RPC_HALF_CLOSED_DETAILS)
+        if not self._metadata_sent.is_set():
+            await self._metadata_sent.wait()
+            if self.done():
+                await self._raise_for_status()
+
+        serialized_request = _common.serialize(request,
+                                               self._request_serializer)
+        try:
+            await self._cython_call.send_serialized_message(serialized_request)
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            await self._raise_for_status()
+
+    async def _done_writing(self) -> None:
+        if self.done():
+            # If the RPC is finished, do nothing.
+            return
+        if not self._done_writing_flag:
+            # If the done writing is not sent before, try to send it.
+            self._done_writing_flag = True
+            try:
+                await self._cython_call.send_receive_close()
+            except asyncio.CancelledError:
+                if not self.cancelled():
+                    self.cancel()
+                await self._raise_for_status()
+
+    async def write(self, request: RequestType) -> None:
+        self._raise_for_different_style(_APIStyle.READER_WRITER)
+        await self._write(request)
+
+    async def done_writing(self) -> None:
+        """Signal peer that client is done writing.
+
+        This method is idempotent.
+        """
+        self._raise_for_different_style(_APIStyle.READER_WRITER)
+        await self._done_writing()
+
+    async def wait_for_connection(self) -> None:
+        await self._metadata_sent.wait()
+        if self.done():
+            await self._raise_for_status()
+
+
+class UnaryUnaryCall(_UnaryResponseMixin, Call, _base_call.UnaryUnaryCall):
+    """Object for managing unary-unary RPC calls.
+
+    Returned when an instance of `UnaryUnaryMultiCallable` object is called.
+    """
+    _request: RequestType
+    _invocation_task: asyncio.Task
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, request: RequestType, deadline: Optional[float],
+                 metadata: Metadata,
+                 credentials: Optional[grpc.CallCredentials],
+                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel,
+                 method: bytes, request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__(
+            channel.call(method, deadline, credentials, wait_for_ready),
+            metadata, request_serializer, response_deserializer, loop)
+        self._request = request
+        self._invocation_task = loop.create_task(self._invoke())
+        self._init_unary_response_mixin(self._invocation_task)
+
+    async def _invoke(self) -> ResponseType:
+        serialized_request = _common.serialize(self._request,
+                                               self._request_serializer)
+
+        # NOTE(lidiz) asyncio.CancelledError is not a good transport for status,
+        # because the asyncio.Task class do not cache the exception object.
+        # https://github.com/python/cpython/blob/edad4d89e357c92f70c0324b937845d652b20afd/Lib/asyncio/tasks.py#L785
+        try:
+            serialized_response = await self._cython_call.unary_unary(
+                serialized_request, self._metadata)
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+
+        if self._cython_call.is_ok():
+            return _common.deserialize(serialized_response,
+                                       self._response_deserializer)
+        else:
+            return cygrpc.EOF
+
+    async def wait_for_connection(self) -> None:
+        await self._invocation_task
+        if self.done():
+            await self._raise_for_status()
+
+
+class UnaryStreamCall(_StreamResponseMixin, Call, _base_call.UnaryStreamCall):
+    """Object for managing unary-stream RPC calls.
+
+    Returned when an instance of `UnaryStreamMultiCallable` object is called.
+    """
+    _request: RequestType
+    _send_unary_request_task: asyncio.Task
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, request: RequestType, deadline: Optional[float],
+                 metadata: Metadata,
+                 credentials: Optional[grpc.CallCredentials],
+                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel,
+                 method: bytes, request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__(
+            channel.call(method, deadline, credentials, wait_for_ready),
+            metadata, request_serializer, response_deserializer, loop)
+        self._request = request
+        self._send_unary_request_task = loop.create_task(
+            self._send_unary_request())
+        self._init_stream_response_mixin(self._send_unary_request_task)
+
+    async def _send_unary_request(self) -> ResponseType:
+        serialized_request = _common.serialize(self._request,
+                                               self._request_serializer)
+        try:
+            await self._cython_call.initiate_unary_stream(
+                serialized_request, self._metadata)
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            raise
+
+    async def wait_for_connection(self) -> None:
+        await self._send_unary_request_task
+        if self.done():
+            await self._raise_for_status()
+
+
+class StreamUnaryCall(_StreamRequestMixin, _UnaryResponseMixin, Call,
+                      _base_call.StreamUnaryCall):
+    """Object for managing stream-unary RPC calls.
+
+    Returned when an instance of `StreamUnaryMultiCallable` object is called.
+    """
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, request_iterator: Optional[RequestIterableType],
+                 deadline: Optional[float], metadata: Metadata,
+                 credentials: Optional[grpc.CallCredentials],
+                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel,
+                 method: bytes, request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__(
+            channel.call(method, deadline, credentials, wait_for_ready),
+            metadata, request_serializer, response_deserializer, loop)
+
+        self._init_stream_request_mixin(request_iterator)
+        self._init_unary_response_mixin(loop.create_task(self._conduct_rpc()))
+
+    async def _conduct_rpc(self) -> ResponseType:
+        try:
+            serialized_response = await self._cython_call.stream_unary(
+                self._metadata, self._metadata_sent_observer)
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+
+        if self._cython_call.is_ok():
+            return _common.deserialize(serialized_response,
+                                       self._response_deserializer)
+        else:
+            return cygrpc.EOF
+
+
+class StreamStreamCall(_StreamRequestMixin, _StreamResponseMixin, Call,
+                       _base_call.StreamStreamCall):
+    """Object for managing stream-stream RPC calls.
+
+    Returned when an instance of `StreamStreamMultiCallable` object is called.
+    """
+    _initializer: asyncio.Task
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, request_iterator: Optional[RequestIterableType],
+                 deadline: Optional[float], metadata: Metadata,
+                 credentials: Optional[grpc.CallCredentials],
+                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel,
+                 method: bytes, request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__(
+            channel.call(method, deadline, credentials, wait_for_ready),
+            metadata, request_serializer, response_deserializer, loop)
+        self._initializer = self._loop.create_task(self._prepare_rpc())
+        self._init_stream_request_mixin(request_iterator)
+        self._init_stream_response_mixin(self._initializer)
+
+    async def _prepare_rpc(self):
+        """This method prepares the RPC for receiving/sending messages.
+
+        All other operations around the stream should only happen after the
+        completion of this method.
+        """
+        try:
+            await self._cython_call.initiate_stream_stream(
+                self._metadata, self._metadata_sent_observer)
+        except asyncio.CancelledError:
+            if not self.cancelled():
+                self.cancel()
+            # No need to raise RpcError here, because no one will `await` this task.
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_channel.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_channel.py
index 0ec0d2176c..3af3467706 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_channel.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_channel.py
@@ -1,469 +1,469 @@
-# Copyright 2019 gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Invocation-side implementation of gRPC Asyncio Python.""" 
- 
-import asyncio 
-import sys 
-from typing import Any, Iterable, Optional, Sequence, List 
- 
-import grpc 
-from grpc import _common, _compression, _grpcio_metadata 
-from grpc._cython import cygrpc 
- 
-from . import _base_call, _base_channel 
-from ._call import (StreamStreamCall, StreamUnaryCall, UnaryStreamCall, 
-                    UnaryUnaryCall) 
-from ._interceptor import ( 
-    InterceptedUnaryUnaryCall, InterceptedUnaryStreamCall, 
-    InterceptedStreamUnaryCall, InterceptedStreamStreamCall, ClientInterceptor, 
-    UnaryUnaryClientInterceptor, UnaryStreamClientInterceptor, 
-    StreamUnaryClientInterceptor, StreamStreamClientInterceptor) 
-from ._metadata import Metadata 
-from ._typing import (ChannelArgumentType, DeserializingFunction, 
-                      SerializingFunction, RequestIterableType) 
-from ._utils import _timeout_to_deadline 
- 
-_USER_AGENT = 'grpc-python-asyncio/{}'.format(_grpcio_metadata.__version__) 
- 
-if sys.version_info[1] < 7: 
- 
-    def _all_tasks() -> Iterable[asyncio.Task]: 
-        return asyncio.Task.all_tasks() 
-else: 
- 
-    def _all_tasks() -> Iterable[asyncio.Task]: 
-        return asyncio.all_tasks() 
- 
- 
-def _augment_channel_arguments(base_options: ChannelArgumentType, 
-                               compression: Optional[grpc.Compression]): 
-    compression_channel_argument = _compression.create_channel_option( 
-        compression) 
-    user_agent_channel_argument = (( 
-        cygrpc.ChannelArgKey.primary_user_agent_string, 
-        _USER_AGENT, 
-    ),) 
-    return tuple(base_options 
-                ) + compression_channel_argument + user_agent_channel_argument 
- 
- 
-class _BaseMultiCallable: 
-    """Base class of all multi callable objects. 
- 
-    Handles the initialization logic and stores common attributes. 
-    """ 
-    _loop: asyncio.AbstractEventLoop 
-    _channel: cygrpc.AioChannel 
-    _method: bytes 
-    _request_serializer: SerializingFunction 
-    _response_deserializer: DeserializingFunction 
-    _interceptors: Optional[Sequence[ClientInterceptor]] 
-    _loop: asyncio.AbstractEventLoop 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__( 
-            self, 
-            channel: cygrpc.AioChannel, 
-            method: bytes, 
-            request_serializer: SerializingFunction, 
-            response_deserializer: DeserializingFunction, 
-            interceptors: Optional[Sequence[ClientInterceptor]], 
-            loop: asyncio.AbstractEventLoop, 
-    ) -> None: 
-        self._loop = loop 
-        self._channel = channel 
-        self._method = method 
-        self._request_serializer = request_serializer 
-        self._response_deserializer = response_deserializer 
-        self._interceptors = interceptors 
- 
-    @staticmethod 
-    def _init_metadata(metadata: Optional[Metadata] = None, 
-                       compression: Optional[grpc.Compression] = None 
-                      ) -> Metadata: 
-        """Based on the provided values for <metadata> or <compression> initialise the final 
-        metadata, as it should be used for the current call. 
-        """ 
-        metadata = metadata or Metadata() 
-        if compression: 
-            metadata = Metadata( 
-                *_compression.augment_metadata(metadata, compression)) 
-        return metadata 
- 
- 
-class UnaryUnaryMultiCallable(_BaseMultiCallable, 
-                              _base_channel.UnaryUnaryMultiCallable): 
- 
-    def __call__(self, 
-                 request: Any, 
-                 *, 
-                 timeout: Optional[float] = None, 
-                 metadata: Optional[Metadata] = None, 
-                 credentials: Optional[grpc.CallCredentials] = None, 
-                 wait_for_ready: Optional[bool] = None, 
-                 compression: Optional[grpc.Compression] = None 
-                ) -> _base_call.UnaryUnaryCall: 
- 
-        metadata = self._init_metadata(metadata, compression) 
-        if not self._interceptors: 
-            call = UnaryUnaryCall(request, _timeout_to_deadline(timeout), 
-                                  metadata, credentials, wait_for_ready, 
-                                  self._channel, self._method, 
-                                  self._request_serializer, 
-                                  self._response_deserializer, self._loop) 
-        else: 
-            call = InterceptedUnaryUnaryCall( 
-                self._interceptors, request, timeout, metadata, credentials, 
-                wait_for_ready, self._channel, self._method, 
-                self._request_serializer, self._response_deserializer, 
-                self._loop) 
- 
-        return call 
- 
- 
-class UnaryStreamMultiCallable(_BaseMultiCallable, 
-                               _base_channel.UnaryStreamMultiCallable): 
- 
-    def __call__(self, 
-                 request: Any, 
-                 *, 
-                 timeout: Optional[float] = None, 
-                 metadata: Optional[Metadata] = None, 
-                 credentials: Optional[grpc.CallCredentials] = None, 
-                 wait_for_ready: Optional[bool] = None, 
-                 compression: Optional[grpc.Compression] = None 
-                ) -> _base_call.UnaryStreamCall: 
- 
-        metadata = self._init_metadata(metadata, compression) 
-        deadline = _timeout_to_deadline(timeout) 
- 
-        if not self._interceptors: 
-            call = UnaryStreamCall(request, deadline, metadata, credentials, 
-                                   wait_for_ready, self._channel, self._method, 
-                                   self._request_serializer, 
-                                   self._response_deserializer, self._loop) 
-        else: 
-            call = InterceptedUnaryStreamCall( 
-                self._interceptors, request, deadline, metadata, credentials, 
-                wait_for_ready, self._channel, self._method, 
-                self._request_serializer, self._response_deserializer, 
-                self._loop) 
- 
-        return call 
- 
- 
-class StreamUnaryMultiCallable(_BaseMultiCallable, 
-                               _base_channel.StreamUnaryMultiCallable): 
- 
-    def __call__(self, 
-                 request_iterator: Optional[RequestIterableType] = None, 
-                 timeout: Optional[float] = None, 
-                 metadata: Optional[Metadata] = None, 
-                 credentials: Optional[grpc.CallCredentials] = None, 
-                 wait_for_ready: Optional[bool] = None, 
-                 compression: Optional[grpc.Compression] = None 
-                ) -> _base_call.StreamUnaryCall: 
- 
-        metadata = self._init_metadata(metadata, compression) 
-        deadline = _timeout_to_deadline(timeout) 
- 
-        if not self._interceptors: 
-            call = StreamUnaryCall(request_iterator, deadline, metadata, 
-                                   credentials, wait_for_ready, self._channel, 
-                                   self._method, self._request_serializer, 
-                                   self._response_deserializer, self._loop) 
-        else: 
-            call = InterceptedStreamUnaryCall( 
-                self._interceptors, request_iterator, deadline, metadata, 
-                credentials, wait_for_ready, self._channel, self._method, 
-                self._request_serializer, self._response_deserializer, 
-                self._loop) 
- 
-        return call 
- 
- 
-class StreamStreamMultiCallable(_BaseMultiCallable, 
-                                _base_channel.StreamStreamMultiCallable): 
- 
-    def __call__(self, 
-                 request_iterator: Optional[RequestIterableType] = None, 
-                 timeout: Optional[float] = None, 
-                 metadata: Optional[Metadata] = None, 
-                 credentials: Optional[grpc.CallCredentials] = None, 
-                 wait_for_ready: Optional[bool] = None, 
-                 compression: Optional[grpc.Compression] = None 
-                ) -> _base_call.StreamStreamCall: 
- 
-        metadata = self._init_metadata(metadata, compression) 
-        deadline = _timeout_to_deadline(timeout) 
- 
-        if not self._interceptors: 
-            call = StreamStreamCall(request_iterator, deadline, metadata, 
-                                    credentials, wait_for_ready, self._channel, 
-                                    self._method, self._request_serializer, 
-                                    self._response_deserializer, self._loop) 
-        else: 
-            call = InterceptedStreamStreamCall( 
-                self._interceptors, request_iterator, deadline, metadata, 
-                credentials, wait_for_ready, self._channel, self._method, 
-                self._request_serializer, self._response_deserializer, 
-                self._loop) 
- 
-        return call 
- 
- 
-class Channel(_base_channel.Channel): 
-    _loop: asyncio.AbstractEventLoop 
-    _channel: cygrpc.AioChannel 
-    _unary_unary_interceptors: List[UnaryUnaryClientInterceptor] 
-    _unary_stream_interceptors: List[UnaryStreamClientInterceptor] 
-    _stream_unary_interceptors: List[StreamUnaryClientInterceptor] 
-    _stream_stream_interceptors: List[StreamStreamClientInterceptor] 
- 
-    def __init__(self, target: str, options: ChannelArgumentType, 
-                 credentials: Optional[grpc.ChannelCredentials], 
-                 compression: Optional[grpc.Compression], 
-                 interceptors: Optional[Sequence[ClientInterceptor]]): 
-        """Constructor. 
- 
-        Args: 
-          target: The target to which to connect. 
-          options: Configuration options for the channel. 
-          credentials: A cygrpc.ChannelCredentials or None. 
-          compression: An optional value indicating the compression method to be 
-            used over the lifetime of the channel. 
-          interceptors: An optional list of interceptors that would be used for 
-            intercepting any RPC executed with that channel. 
-        """ 
-        self._unary_unary_interceptors = [] 
-        self._unary_stream_interceptors = [] 
-        self._stream_unary_interceptors = [] 
-        self._stream_stream_interceptors = [] 
- 
-        if interceptors is not None: 
-            for interceptor in interceptors: 
-                if isinstance(interceptor, UnaryUnaryClientInterceptor): 
-                    self._unary_unary_interceptors.append(interceptor) 
-                elif isinstance(interceptor, UnaryStreamClientInterceptor): 
-                    self._unary_stream_interceptors.append(interceptor) 
-                elif isinstance(interceptor, StreamUnaryClientInterceptor): 
-                    self._stream_unary_interceptors.append(interceptor) 
-                elif isinstance(interceptor, StreamStreamClientInterceptor): 
-                    self._stream_stream_interceptors.append(interceptor) 
-                else: 
-                    raise ValueError( 
-                        "Interceptor {} must be ".format(interceptor) + 
-                        "{} or ".format(UnaryUnaryClientInterceptor.__name__) + 
-                        "{} or ".format(UnaryStreamClientInterceptor.__name__) + 
-                        "{} or ".format(StreamUnaryClientInterceptor.__name__) + 
-                        "{}. ".format(StreamStreamClientInterceptor.__name__)) 
- 
-        self._loop = cygrpc.get_working_loop() 
-        self._channel = cygrpc.AioChannel( 
-            _common.encode(target), 
-            _augment_channel_arguments(options, compression), credentials, 
-            self._loop) 
- 
-    async def __aenter__(self): 
-        return self 
- 
-    async def __aexit__(self, exc_type, exc_val, exc_tb): 
-        await self._close(None) 
- 
-    async def _close(self, grace):  # pylint: disable=too-many-branches 
-        if self._channel.closed(): 
-            return 
- 
-        # No new calls will be accepted by the Cython channel. 
-        self._channel.closing() 
- 
-        # Iterate through running tasks 
-        tasks = _all_tasks() 
-        calls = [] 
-        call_tasks = [] 
-        for task in tasks: 
-            try: 
-                stack = task.get_stack(limit=1) 
-            except AttributeError as attribute_error: 
-                # NOTE(lidiz) tl;dr: If the Task is created with a CPython 
-                # object, it will trigger AttributeError. 
-                # 
-                # In the global finalizer, the event loop schedules 
-                # a CPython PyAsyncGenAThrow object. 
-                # https://github.com/python/cpython/blob/00e45877e33d32bb61aa13a2033e3bba370bda4d/Lib/asyncio/base_events.py#L484 
-                # 
-                # However, the PyAsyncGenAThrow object is written in C and 
-                # failed to include the normal Python frame objects. Hence, 
-                # this exception is a false negative, and it is safe to ignore 
-                # the failure. It is fixed by https://github.com/python/cpython/pull/18669, 
-                # but not available until 3.9 or 3.8.3. So, we have to keep it 
-                # for a while. 
-                # TODO(lidiz) drop this hack after 3.8 deprecation 
-                if 'frame' in str(attribute_error): 
-                    continue 
-                else: 
-                    raise 
- 
-            # If the Task is created by a C-extension, the stack will be empty. 
-            if not stack: 
-                continue 
- 
-            # Locate ones created by `aio.Call`. 
-            frame = stack[0] 
-            candidate = frame.f_locals.get('self') 
-            if candidate: 
-                if isinstance(candidate, _base_call.Call): 
-                    if hasattr(candidate, '_channel'): 
-                        # For intercepted Call object 
-                        if candidate._channel is not self._channel: 
-                            continue 
-                    elif hasattr(candidate, '_cython_call'): 
-                        # For normal Call object 
-                        if candidate._cython_call._channel is not self._channel: 
-                            continue 
-                    else: 
-                        # Unidentified Call object 
-                        raise cygrpc.InternalError( 
-                            f'Unrecognized call object: {candidate}') 
- 
-                    calls.append(candidate) 
-                    call_tasks.append(task) 
- 
-        # If needed, try to wait for them to finish. 
-        # Call objects are not always awaitables. 
-        if grace and call_tasks: 
-            await asyncio.wait(call_tasks, timeout=grace, loop=self._loop) 
- 
-        # Time to cancel existing calls. 
-        for call in calls: 
-            call.cancel() 
- 
-        # Destroy the channel 
-        self._channel.close() 
- 
-    async def close(self, grace: Optional[float] = None): 
-        await self._close(grace) 
- 
-    def get_state(self, 
-                  try_to_connect: bool = False) -> grpc.ChannelConnectivity: 
-        result = self._channel.check_connectivity_state(try_to_connect) 
-        return _common.CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[result] 
- 
-    async def wait_for_state_change( 
-            self, 
-            last_observed_state: grpc.ChannelConnectivity, 
-    ) -> None: 
-        assert await self._channel.watch_connectivity_state( 
-            last_observed_state.value[0], None) 
- 
-    async def channel_ready(self) -> None: 
-        state = self.get_state(try_to_connect=True) 
-        while state != grpc.ChannelConnectivity.READY: 
-            await self.wait_for_state_change(state) 
-            state = self.get_state(try_to_connect=True) 
- 
-    def unary_unary( 
-            self, 
-            method: str, 
-            request_serializer: Optional[SerializingFunction] = None, 
-            response_deserializer: Optional[DeserializingFunction] = None 
-    ) -> UnaryUnaryMultiCallable: 
-        return UnaryUnaryMultiCallable(self._channel, _common.encode(method), 
-                                       request_serializer, 
-                                       response_deserializer, 
-                                       self._unary_unary_interceptors, 
-                                       self._loop) 
- 
-    def unary_stream( 
-            self, 
-            method: str, 
-            request_serializer: Optional[SerializingFunction] = None, 
-            response_deserializer: Optional[DeserializingFunction] = None 
-    ) -> UnaryStreamMultiCallable: 
-        return UnaryStreamMultiCallable(self._channel, _common.encode(method), 
-                                        request_serializer, 
-                                        response_deserializer, 
-                                        self._unary_stream_interceptors, 
-                                        self._loop) 
- 
-    def stream_unary( 
-            self, 
-            method: str, 
-            request_serializer: Optional[SerializingFunction] = None, 
-            response_deserializer: Optional[DeserializingFunction] = None 
-    ) -> StreamUnaryMultiCallable: 
-        return StreamUnaryMultiCallable(self._channel, _common.encode(method), 
-                                        request_serializer, 
-                                        response_deserializer, 
-                                        self._stream_unary_interceptors, 
-                                        self._loop) 
- 
-    def stream_stream( 
-            self, 
-            method: str, 
-            request_serializer: Optional[SerializingFunction] = None, 
-            response_deserializer: Optional[DeserializingFunction] = None 
-    ) -> StreamStreamMultiCallable: 
-        return StreamStreamMultiCallable(self._channel, _common.encode(method), 
-                                         request_serializer, 
-                                         response_deserializer, 
-                                         self._stream_stream_interceptors, 
-                                         self._loop) 
- 
- 
-def insecure_channel( 
-        target: str, 
-        options: Optional[ChannelArgumentType] = None, 
-        compression: Optional[grpc.Compression] = None, 
-        interceptors: Optional[Sequence[ClientInterceptor]] = None): 
-    """Creates an insecure asynchronous Channel to a server. 
- 
-    Args: 
-      target: The server address 
-      options: An optional list of key-value pairs (:term:`channel_arguments` 
-        in gRPC Core runtime) to configure the channel. 
-      compression: An optional value indicating the compression method to be 
-        used over the lifetime of the channel. This is an EXPERIMENTAL option. 
-      interceptors: An optional sequence of interceptors that will be executed for 
-        any call executed with this channel. 
- 
-    Returns: 
-      A Channel. 
-    """ 
-    return Channel(target, () if options is None else options, None, 
-                   compression, interceptors) 
- 
- 
-def secure_channel(target: str, 
-                   credentials: grpc.ChannelCredentials, 
-                   options: Optional[ChannelArgumentType] = None, 
-                   compression: Optional[grpc.Compression] = None, 
-                   interceptors: Optional[Sequence[ClientInterceptor]] = None): 
-    """Creates a secure asynchronous Channel to a server. 
- 
-    Args: 
-      target: The server address. 
-      credentials: A ChannelCredentials instance. 
-      options: An optional list of key-value pairs (:term:`channel_arguments` 
-        in gRPC Core runtime) to configure the channel. 
-      compression: An optional value indicating the compression method to be 
-        used over the lifetime of the channel. This is an EXPERIMENTAL option. 
-      interceptors: An optional sequence of interceptors that will be executed for 
-        any call executed with this channel. 
- 
-    Returns: 
-      An aio.Channel. 
-    """ 
-    return Channel(target, () if options is None else options, 
-                   credentials._credentials, compression, interceptors) 
+# Copyright 2019 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Invocation-side implementation of gRPC Asyncio Python."""
+
+import asyncio
+import sys
+from typing import Any, Iterable, Optional, Sequence, List
+
+import grpc
+from grpc import _common, _compression, _grpcio_metadata
+from grpc._cython import cygrpc
+
+from . import _base_call, _base_channel
+from ._call import (StreamStreamCall, StreamUnaryCall, UnaryStreamCall,
+                    UnaryUnaryCall)
+from ._interceptor import (
+    InterceptedUnaryUnaryCall, InterceptedUnaryStreamCall,
+    InterceptedStreamUnaryCall, InterceptedStreamStreamCall, ClientInterceptor,
+    UnaryUnaryClientInterceptor, UnaryStreamClientInterceptor,
+    StreamUnaryClientInterceptor, StreamStreamClientInterceptor)
+from ._metadata import Metadata
+from ._typing import (ChannelArgumentType, DeserializingFunction,
+                      SerializingFunction, RequestIterableType)
+from ._utils import _timeout_to_deadline
+
+_USER_AGENT = 'grpc-python-asyncio/{}'.format(_grpcio_metadata.__version__)
+
+if sys.version_info[1] < 7:
+
+    def _all_tasks() -> Iterable[asyncio.Task]:
+        return asyncio.Task.all_tasks()
+else:
+
+    def _all_tasks() -> Iterable[asyncio.Task]:
+        return asyncio.all_tasks()
+
+
+def _augment_channel_arguments(base_options: ChannelArgumentType,
+                               compression: Optional[grpc.Compression]):
+    compression_channel_argument = _compression.create_channel_option(
+        compression)
+    user_agent_channel_argument = ((
+        cygrpc.ChannelArgKey.primary_user_agent_string,
+        _USER_AGENT,
+    ),)
+    return tuple(base_options
+                ) + compression_channel_argument + user_agent_channel_argument
+
+
+class _BaseMultiCallable:
+    """Base class of all multi callable objects.
+
+    Handles the initialization logic and stores common attributes.
+    """
+    _loop: asyncio.AbstractEventLoop
+    _channel: cygrpc.AioChannel
+    _method: bytes
+    _request_serializer: SerializingFunction
+    _response_deserializer: DeserializingFunction
+    _interceptors: Optional[Sequence[ClientInterceptor]]
+    _loop: asyncio.AbstractEventLoop
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+            self,
+            channel: cygrpc.AioChannel,
+            method: bytes,
+            request_serializer: SerializingFunction,
+            response_deserializer: DeserializingFunction,
+            interceptors: Optional[Sequence[ClientInterceptor]],
+            loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        self._loop = loop
+        self._channel = channel
+        self._method = method
+        self._request_serializer = request_serializer
+        self._response_deserializer = response_deserializer
+        self._interceptors = interceptors
+
+    @staticmethod
+    def _init_metadata(metadata: Optional[Metadata] = None,
+                       compression: Optional[grpc.Compression] = None
+                      ) -> Metadata:
+        """Based on the provided values for <metadata> or <compression> initialise the final
+        metadata, as it should be used for the current call.
+        """
+        metadata = metadata or Metadata()
+        if compression:
+            metadata = Metadata(
+                *_compression.augment_metadata(metadata, compression))
+        return metadata
+
+
+class UnaryUnaryMultiCallable(_BaseMultiCallable,
+                              _base_channel.UnaryUnaryMultiCallable):
+
+    def __call__(self,
+                 request: Any,
+                 *,
+                 timeout: Optional[float] = None,
+                 metadata: Optional[Metadata] = None,
+                 credentials: Optional[grpc.CallCredentials] = None,
+                 wait_for_ready: Optional[bool] = None,
+                 compression: Optional[grpc.Compression] = None
+                ) -> _base_call.UnaryUnaryCall:
+
+        metadata = self._init_metadata(metadata, compression)
+        if not self._interceptors:
+            call = UnaryUnaryCall(request, _timeout_to_deadline(timeout),
+                                  metadata, credentials, wait_for_ready,
+                                  self._channel, self._method,
+                                  self._request_serializer,
+                                  self._response_deserializer, self._loop)
+        else:
+            call = InterceptedUnaryUnaryCall(
+                self._interceptors, request, timeout, metadata, credentials,
+                wait_for_ready, self._channel, self._method,
+                self._request_serializer, self._response_deserializer,
+                self._loop)
+
+        return call
+
+
+class UnaryStreamMultiCallable(_BaseMultiCallable,
+                               _base_channel.UnaryStreamMultiCallable):
+
+    def __call__(self,
+                 request: Any,
+                 *,
+                 timeout: Optional[float] = None,
+                 metadata: Optional[Metadata] = None,
+                 credentials: Optional[grpc.CallCredentials] = None,
+                 wait_for_ready: Optional[bool] = None,
+                 compression: Optional[grpc.Compression] = None
+                ) -> _base_call.UnaryStreamCall:
+
+        metadata = self._init_metadata(metadata, compression)
+        deadline = _timeout_to_deadline(timeout)
+
+        if not self._interceptors:
+            call = UnaryStreamCall(request, deadline, metadata, credentials,
+                                   wait_for_ready, self._channel, self._method,
+                                   self._request_serializer,
+                                   self._response_deserializer, self._loop)
+        else:
+            call = InterceptedUnaryStreamCall(
+                self._interceptors, request, deadline, metadata, credentials,
+                wait_for_ready, self._channel, self._method,
+                self._request_serializer, self._response_deserializer,
+                self._loop)
+
+        return call
+
+
+class StreamUnaryMultiCallable(_BaseMultiCallable,
+                               _base_channel.StreamUnaryMultiCallable):
+
+    def __call__(self,
+                 request_iterator: Optional[RequestIterableType] = None,
+                 timeout: Optional[float] = None,
+                 metadata: Optional[Metadata] = None,
+                 credentials: Optional[grpc.CallCredentials] = None,
+                 wait_for_ready: Optional[bool] = None,
+                 compression: Optional[grpc.Compression] = None
+                ) -> _base_call.StreamUnaryCall:
+
+        metadata = self._init_metadata(metadata, compression)
+        deadline = _timeout_to_deadline(timeout)
+
+        if not self._interceptors:
+            call = StreamUnaryCall(request_iterator, deadline, metadata,
+                                   credentials, wait_for_ready, self._channel,
+                                   self._method, self._request_serializer,
+                                   self._response_deserializer, self._loop)
+        else:
+            call = InterceptedStreamUnaryCall(
+                self._interceptors, request_iterator, deadline, metadata,
+                credentials, wait_for_ready, self._channel, self._method,
+                self._request_serializer, self._response_deserializer,
+                self._loop)
+
+        return call
+
+
+class StreamStreamMultiCallable(_BaseMultiCallable,
+                                _base_channel.StreamStreamMultiCallable):
+
+    def __call__(self,
+                 request_iterator: Optional[RequestIterableType] = None,
+                 timeout: Optional[float] = None,
+                 metadata: Optional[Metadata] = None,
+                 credentials: Optional[grpc.CallCredentials] = None,
+                 wait_for_ready: Optional[bool] = None,
+                 compression: Optional[grpc.Compression] = None
+                ) -> _base_call.StreamStreamCall:
+
+        metadata = self._init_metadata(metadata, compression)
+        deadline = _timeout_to_deadline(timeout)
+
+        if not self._interceptors:
+            call = StreamStreamCall(request_iterator, deadline, metadata,
+                                    credentials, wait_for_ready, self._channel,
+                                    self._method, self._request_serializer,
+                                    self._response_deserializer, self._loop)
+        else:
+            call = InterceptedStreamStreamCall(
+                self._interceptors, request_iterator, deadline, metadata,
+                credentials, wait_for_ready, self._channel, self._method,
+                self._request_serializer, self._response_deserializer,
+                self._loop)
+
+        return call
+
+
+class Channel(_base_channel.Channel):
+    _loop: asyncio.AbstractEventLoop
+    _channel: cygrpc.AioChannel
+    _unary_unary_interceptors: List[UnaryUnaryClientInterceptor]
+    _unary_stream_interceptors: List[UnaryStreamClientInterceptor]
+    _stream_unary_interceptors: List[StreamUnaryClientInterceptor]
+    _stream_stream_interceptors: List[StreamStreamClientInterceptor]
+
+    def __init__(self, target: str, options: ChannelArgumentType,
+                 credentials: Optional[grpc.ChannelCredentials],
+                 compression: Optional[grpc.Compression],
+                 interceptors: Optional[Sequence[ClientInterceptor]]):
+        """Constructor.
+
+        Args:
+          target: The target to which to connect.
+          options: Configuration options for the channel.
+          credentials: A cygrpc.ChannelCredentials or None.
+          compression: An optional value indicating the compression method to be
+            used over the lifetime of the channel.
+          interceptors: An optional list of interceptors that would be used for
+            intercepting any RPC executed with that channel.
+        """
+        self._unary_unary_interceptors = []
+        self._unary_stream_interceptors = []
+        self._stream_unary_interceptors = []
+        self._stream_stream_interceptors = []
+
+        if interceptors is not None:
+            for interceptor in interceptors:
+                if isinstance(interceptor, UnaryUnaryClientInterceptor):
+                    self._unary_unary_interceptors.append(interceptor)
+                elif isinstance(interceptor, UnaryStreamClientInterceptor):
+                    self._unary_stream_interceptors.append(interceptor)
+                elif isinstance(interceptor, StreamUnaryClientInterceptor):
+                    self._stream_unary_interceptors.append(interceptor)
+                elif isinstance(interceptor, StreamStreamClientInterceptor):
+                    self._stream_stream_interceptors.append(interceptor)
+                else:
+                    raise ValueError(
+                        "Interceptor {} must be ".format(interceptor) +
+                        "{} or ".format(UnaryUnaryClientInterceptor.__name__) +
+                        "{} or ".format(UnaryStreamClientInterceptor.__name__) +
+                        "{} or ".format(StreamUnaryClientInterceptor.__name__) +
+                        "{}. ".format(StreamStreamClientInterceptor.__name__))
+
+        self._loop = cygrpc.get_working_loop()
+        self._channel = cygrpc.AioChannel(
+            _common.encode(target),
+            _augment_channel_arguments(options, compression), credentials,
+            self._loop)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self._close(None)
+
+    async def _close(self, grace):  # pylint: disable=too-many-branches
+        if self._channel.closed():
+            return
+
+        # No new calls will be accepted by the Cython channel.
+        self._channel.closing()
+
+        # Iterate through running tasks
+        tasks = _all_tasks()
+        calls = []
+        call_tasks = []
+        for task in tasks:
+            try:
+                stack = task.get_stack(limit=1)
+            except AttributeError as attribute_error:
+                # NOTE(lidiz) tl;dr: If the Task is created with a CPython
+                # object, it will trigger AttributeError.
+                #
+                # In the global finalizer, the event loop schedules
+                # a CPython PyAsyncGenAThrow object.
+                # https://github.com/python/cpython/blob/00e45877e33d32bb61aa13a2033e3bba370bda4d/Lib/asyncio/base_events.py#L484
+                #
+                # However, the PyAsyncGenAThrow object is written in C and
+                # failed to include the normal Python frame objects. Hence,
+                # this exception is a false negative, and it is safe to ignore
+                # the failure. It is fixed by https://github.com/python/cpython/pull/18669,
+                # but not available until 3.9 or 3.8.3. So, we have to keep it
+                # for a while.
+                # TODO(lidiz) drop this hack after 3.8 deprecation
+                if 'frame' in str(attribute_error):
+                    continue
+                else:
+                    raise
+
+            # If the Task is created by a C-extension, the stack will be empty.
+            if not stack:
+                continue
+
+            # Locate ones created by `aio.Call`.
+            frame = stack[0]
+            candidate = frame.f_locals.get('self')
+            if candidate:
+                if isinstance(candidate, _base_call.Call):
+                    if hasattr(candidate, '_channel'):
+                        # For intercepted Call object
+                        if candidate._channel is not self._channel:
+                            continue
+                    elif hasattr(candidate, '_cython_call'):
+                        # For normal Call object
+                        if candidate._cython_call._channel is not self._channel:
+                            continue
+                    else:
+                        # Unidentified Call object
+                        raise cygrpc.InternalError(
+                            f'Unrecognized call object: {candidate}')
+
+                    calls.append(candidate)
+                    call_tasks.append(task)
+
+        # If needed, try to wait for them to finish.
+        # Call objects are not always awaitables.
+        if grace and call_tasks:
+            await asyncio.wait(call_tasks, timeout=grace, loop=self._loop)
+
+        # Time to cancel existing calls.
+        for call in calls:
+            call.cancel()
+
+        # Destroy the channel
+        self._channel.close()
+
+    async def close(self, grace: Optional[float] = None):
+        await self._close(grace)
+
+    def get_state(self,
+                  try_to_connect: bool = False) -> grpc.ChannelConnectivity:
+        result = self._channel.check_connectivity_state(try_to_connect)
+        return _common.CYGRPC_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[result]
+
+    async def wait_for_state_change(
+            self,
+            last_observed_state: grpc.ChannelConnectivity,
+    ) -> None:
+        assert await self._channel.watch_connectivity_state(
+            last_observed_state.value[0], None)
+
+    async def channel_ready(self) -> None:
+        state = self.get_state(try_to_connect=True)
+        while state != grpc.ChannelConnectivity.READY:
+            await self.wait_for_state_change(state)
+            state = self.get_state(try_to_connect=True)
+
+    def unary_unary(
+            self,
+            method: str,
+            request_serializer: Optional[SerializingFunction] = None,
+            response_deserializer: Optional[DeserializingFunction] = None
+    ) -> UnaryUnaryMultiCallable:
+        return UnaryUnaryMultiCallable(self._channel, _common.encode(method),
+                                       request_serializer,
+                                       response_deserializer,
+                                       self._unary_unary_interceptors,
+                                       self._loop)
+
+    def unary_stream(
+            self,
+            method: str,
+            request_serializer: Optional[SerializingFunction] = None,
+            response_deserializer: Optional[DeserializingFunction] = None
+    ) -> UnaryStreamMultiCallable:
+        return UnaryStreamMultiCallable(self._channel, _common.encode(method),
+                                        request_serializer,
+                                        response_deserializer,
+                                        self._unary_stream_interceptors,
+                                        self._loop)
+
+    def stream_unary(
+            self,
+            method: str,
+            request_serializer: Optional[SerializingFunction] = None,
+            response_deserializer: Optional[DeserializingFunction] = None
+    ) -> StreamUnaryMultiCallable:
+        return StreamUnaryMultiCallable(self._channel, _common.encode(method),
+                                        request_serializer,
+                                        response_deserializer,
+                                        self._stream_unary_interceptors,
+                                        self._loop)
+
+    def stream_stream(
+            self,
+            method: str,
+            request_serializer: Optional[SerializingFunction] = None,
+            response_deserializer: Optional[DeserializingFunction] = None
+    ) -> StreamStreamMultiCallable:
+        return StreamStreamMultiCallable(self._channel, _common.encode(method),
+                                         request_serializer,
+                                         response_deserializer,
+                                         self._stream_stream_interceptors,
+                                         self._loop)
+
+
+def insecure_channel(
+        target: str,
+        options: Optional[ChannelArgumentType] = None,
+        compression: Optional[grpc.Compression] = None,
+        interceptors: Optional[Sequence[ClientInterceptor]] = None):
+    """Creates an insecure asynchronous Channel to a server.
+
+    Args:
+      target: The server address
+      options: An optional list of key-value pairs (:term:`channel_arguments`
+        in gRPC Core runtime) to configure the channel.
+      compression: An optional value indicating the compression method to be
+        used over the lifetime of the channel. This is an EXPERIMENTAL option.
+      interceptors: An optional sequence of interceptors that will be executed for
+        any call executed with this channel.
+
+    Returns:
+      A Channel.
+    """
+    return Channel(target, () if options is None else options, None,
+                   compression, interceptors)
+
+
+def secure_channel(target: str,
+                   credentials: grpc.ChannelCredentials,
+                   options: Optional[ChannelArgumentType] = None,
+                   compression: Optional[grpc.Compression] = None,
+                   interceptors: Optional[Sequence[ClientInterceptor]] = None):
+    """Creates a secure asynchronous Channel to a server.
+
+    Args:
+      target: The server address.
+      credentials: A ChannelCredentials instance.
+      options: An optional list of key-value pairs (:term:`channel_arguments`
+        in gRPC Core runtime) to configure the channel.
+      compression: An optional value indicating the compression method to be
+        used over the lifetime of the channel. This is an EXPERIMENTAL option.
+      interceptors: An optional sequence of interceptors that will be executed for
+        any call executed with this channel.
+
+    Returns:
+      An aio.Channel.
+    """
+    return Channel(target, () if options is None else options,
+                   credentials._credentials, compression, interceptors)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_interceptor.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_interceptor.py
index 6f899cd461..80e9625c55 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_interceptor.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_interceptor.py
@@ -1,987 +1,987 @@
-# Copyright 2019 gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Interceptors implementation of gRPC Asyncio Python.""" 
-import asyncio 
-import collections 
-import functools 
-from abc import ABCMeta, abstractmethod 
-from typing import Callable, Optional, Iterator, Sequence, Union, Awaitable, AsyncIterable 
- 
-import grpc 
-from grpc._cython import cygrpc 
- 
-from . import _base_call 
-from ._call import UnaryUnaryCall, UnaryStreamCall, StreamUnaryCall, StreamStreamCall, AioRpcError 
-from ._call import _RPC_ALREADY_FINISHED_DETAILS, _RPC_HALF_CLOSED_DETAILS 
-from ._call import _API_STYLE_ERROR 
-from ._utils import _timeout_to_deadline 
-from ._typing import (RequestType, SerializingFunction, DeserializingFunction, 
-                      ResponseType, DoneCallbackType, RequestIterableType, 
-                      ResponseIterableType) 
-from ._metadata import Metadata 
- 
-_LOCAL_CANCELLATION_DETAILS = 'Locally cancelled by application!' 
- 
- 
-class ServerInterceptor(metaclass=ABCMeta): 
-    """Affords intercepting incoming RPCs on the service-side. 
- 
-    This is an EXPERIMENTAL API. 
-    """ 
- 
-    @abstractmethod 
-    async def intercept_service( 
-            self, continuation: Callable[[grpc.HandlerCallDetails], Awaitable[ 
-                grpc.RpcMethodHandler]], 
-            handler_call_details: grpc.HandlerCallDetails 
-    ) -> grpc.RpcMethodHandler: 
-        """Intercepts incoming RPCs before handing them over to a handler. 
- 
-        Args: 
-            continuation: A function that takes a HandlerCallDetails and 
-                proceeds to invoke the next interceptor in the chain, if any, 
-                or the RPC handler lookup logic, with the call details passed 
-                as an argument, and returns an RpcMethodHandler instance if 
-                the RPC is considered serviced, or None otherwise. 
-            handler_call_details: A HandlerCallDetails describing the RPC. 
- 
-        Returns: 
-            An RpcMethodHandler with which the RPC may be serviced if the 
-            interceptor chooses to service this RPC, or None otherwise. 
-        """ 
- 
- 
-class ClientCallDetails( 
-        collections.namedtuple( 
-            'ClientCallDetails', 
-            ('method', 'timeout', 'metadata', 'credentials', 'wait_for_ready')), 
-        grpc.ClientCallDetails): 
-    """Describes an RPC to be invoked. 
- 
-    This is an EXPERIMENTAL API. 
- 
-    Args: 
-        method: The method name of the RPC. 
-        timeout: An optional duration of time in seconds to allow for the RPC. 
-        metadata: Optional metadata to be transmitted to the service-side of 
-          the RPC. 
-        credentials: An optional CallCredentials for the RPC. 
-        wait_for_ready: This is an EXPERIMENTAL argument. An optional 
-            flag to enable :term:`wait_for_ready` mechanism. 
-    """ 
- 
-    method: str 
-    timeout: Optional[float] 
-    metadata: Optional[Metadata] 
-    credentials: Optional[grpc.CallCredentials] 
-    wait_for_ready: Optional[bool] 
- 
- 
-class ClientInterceptor(metaclass=ABCMeta): 
-    """Base class used for all Aio Client Interceptor classes""" 
- 
- 
-class UnaryUnaryClientInterceptor(ClientInterceptor, metaclass=ABCMeta): 
-    """Affords intercepting unary-unary invocations.""" 
- 
-    @abstractmethod 
-    async def intercept_unary_unary( 
-            self, continuation: Callable[[ClientCallDetails, RequestType], 
-                                         UnaryUnaryCall], 
-            client_call_details: ClientCallDetails, 
-            request: RequestType) -> Union[UnaryUnaryCall, ResponseType]: 
-        """Intercepts a unary-unary invocation asynchronously. 
- 
-        Args: 
-          continuation: A coroutine that proceeds with the invocation by 
-            executing the next interceptor in the chain or invoking the 
-            actual RPC on the underlying Channel. It is the interceptor's 
-            responsibility to call it if it decides to move the RPC forward. 
-            The interceptor can use 
-            `call = await continuation(client_call_details, request)` 
-            to continue with the RPC. `continuation` returns the call to the 
-            RPC. 
-          client_call_details: A ClientCallDetails object describing the 
-            outgoing RPC. 
-          request: The request value for the RPC. 
- 
-        Returns: 
-          An object with the RPC response. 
- 
-        Raises: 
-          AioRpcError: Indicating that the RPC terminated with non-OK status. 
-          asyncio.CancelledError: Indicating that the RPC was canceled. 
-        """ 
- 
- 
-class UnaryStreamClientInterceptor(ClientInterceptor, metaclass=ABCMeta): 
-    """Affords intercepting unary-stream invocations.""" 
- 
-    @abstractmethod 
-    async def intercept_unary_stream( 
-            self, continuation: Callable[[ClientCallDetails, RequestType], 
-                                         UnaryStreamCall], 
-            client_call_details: ClientCallDetails, request: RequestType 
-    ) -> Union[ResponseIterableType, UnaryStreamCall]: 
-        """Intercepts a unary-stream invocation asynchronously. 
- 
-        The function could return the call object or an asynchronous 
-        iterator, in case of being an asyncrhonous iterator this will 
-        become the source of the reads done by the caller. 
- 
-        Args: 
-          continuation: A coroutine that proceeds with the invocation by 
-            executing the next interceptor in the chain or invoking the 
-            actual RPC on the underlying Channel. It is the interceptor's 
-            responsibility to call it if it decides to move the RPC forward. 
-            The interceptor can use 
-            `call = await continuation(client_call_details, request)` 
-            to continue with the RPC. `continuation` returns the call to the 
-            RPC. 
-          client_call_details: A ClientCallDetails object describing the 
-            outgoing RPC. 
-          request: The request value for the RPC. 
- 
-        Returns: 
-          The RPC Call or an asynchronous iterator. 
- 
-        Raises: 
-          AioRpcError: Indicating that the RPC terminated with non-OK status. 
-          asyncio.CancelledError: Indicating that the RPC was canceled. 
-        """ 
- 
- 
-class StreamUnaryClientInterceptor(ClientInterceptor, metaclass=ABCMeta): 
-    """Affords intercepting stream-unary invocations.""" 
- 
-    @abstractmethod 
-    async def intercept_stream_unary( 
-            self, 
-            continuation: Callable[[ClientCallDetails, RequestType], 
-                                   UnaryStreamCall], 
-            client_call_details: ClientCallDetails, 
-            request_iterator: RequestIterableType, 
-    ) -> StreamUnaryCall: 
-        """Intercepts a stream-unary invocation asynchronously. 
- 
-        Within the interceptor the usage of the call methods like `write` or 
-        even awaiting the call should be done carefully, since the caller 
-        could be expecting an untouched call, for example for start writing 
-        messages to it. 
- 
-        Args: 
-          continuation: A coroutine that proceeds with the invocation by 
-            executing the next interceptor in the chain or invoking the 
-            actual RPC on the underlying Channel. It is the interceptor's 
-            responsibility to call it if it decides to move the RPC forward. 
-            The interceptor can use 
-            `call = await continuation(client_call_details, request_iterator)` 
-            to continue with the RPC. `continuation` returns the call to the 
-            RPC. 
-          client_call_details: A ClientCallDetails object describing the 
-            outgoing RPC. 
-          request_iterator: The request iterator that will produce requests 
-            for the RPC. 
- 
-        Returns: 
-          The RPC Call. 
- 
-        Raises: 
-          AioRpcError: Indicating that the RPC terminated with non-OK status. 
-          asyncio.CancelledError: Indicating that the RPC was canceled. 
-        """ 
- 
- 
-class StreamStreamClientInterceptor(ClientInterceptor, metaclass=ABCMeta): 
-    """Affords intercepting stream-stream invocations.""" 
- 
-    @abstractmethod 
-    async def intercept_stream_stream( 
-            self, 
-            continuation: Callable[[ClientCallDetails, RequestType], 
-                                   UnaryStreamCall], 
-            client_call_details: ClientCallDetails, 
-            request_iterator: RequestIterableType, 
-    ) -> Union[ResponseIterableType, StreamStreamCall]: 
-        """Intercepts a stream-stream invocation asynchronously. 
- 
-        Within the interceptor the usage of the call methods like `write` or 
-        even awaiting the call should be done carefully, since the caller 
-        could be expecting an untouched call, for example for start writing 
-        messages to it. 
- 
-        The function could return the call object or an asynchronous 
-        iterator, in case of being an asyncrhonous iterator this will 
-        become the source of the reads done by the caller. 
- 
-        Args: 
-          continuation: A coroutine that proceeds with the invocation by 
-            executing the next interceptor in the chain or invoking the 
-            actual RPC on the underlying Channel. It is the interceptor's 
-            responsibility to call it if it decides to move the RPC forward. 
-            The interceptor can use 
-            `call = await continuation(client_call_details, request_iterator)` 
-            to continue with the RPC. `continuation` returns the call to the 
-            RPC. 
-          client_call_details: A ClientCallDetails object describing the 
-            outgoing RPC. 
-          request_iterator: The request iterator that will produce requests 
-            for the RPC. 
- 
-        Returns: 
-          The RPC Call or an asynchronous iterator. 
- 
-        Raises: 
-          AioRpcError: Indicating that the RPC terminated with non-OK status. 
-          asyncio.CancelledError: Indicating that the RPC was canceled. 
-        """ 
- 
- 
-class InterceptedCall: 
-    """Base implementation for all intercepted call arities. 
- 
-    Interceptors might have some work to do before the RPC invocation with 
-    the capacity of changing the invocation parameters, and some work to do 
-    after the RPC invocation with the capacity for accessing to the wrapped 
-    `UnaryUnaryCall`. 
- 
-    It handles also early and later cancellations, when the RPC has not even 
-    started and the execution is still held by the interceptors or when the 
-    RPC has finished but again the execution is still held by the interceptors. 
- 
-    Once the RPC is finally executed, all methods are finally done against the 
-    intercepted call, being at the same time the same call returned to the 
-    interceptors. 
- 
-    As a base class for all of the interceptors implements the logic around 
-    final status, metadata and cancellation. 
-    """ 
- 
-    _interceptors_task: asyncio.Task 
-    _pending_add_done_callbacks: Sequence[DoneCallbackType] 
- 
-    def __init__(self, interceptors_task: asyncio.Task) -> None: 
-        self._interceptors_task = interceptors_task 
-        self._pending_add_done_callbacks = [] 
-        self._interceptors_task.add_done_callback( 
-            self._fire_or_add_pending_done_callbacks) 
- 
-    def __del__(self): 
-        self.cancel() 
- 
-    def _fire_or_add_pending_done_callbacks(self, 
-                                            interceptors_task: asyncio.Task 
-                                           ) -> None: 
- 
-        if not self._pending_add_done_callbacks: 
-            return 
- 
-        call_completed = False 
- 
-        try: 
-            call = interceptors_task.result() 
-            if call.done(): 
-                call_completed = True 
-        except (AioRpcError, asyncio.CancelledError): 
-            call_completed = True 
- 
-        if call_completed: 
-            for callback in self._pending_add_done_callbacks: 
-                callback(self) 
-        else: 
-            for callback in self._pending_add_done_callbacks: 
-                callback = functools.partial(self._wrap_add_done_callback, 
-                                             callback) 
-                call.add_done_callback(callback) 
- 
-        self._pending_add_done_callbacks = [] 
- 
-    def _wrap_add_done_callback(self, callback: DoneCallbackType, 
-                                unused_call: _base_call.Call) -> None: 
-        callback(self) 
- 
-    def cancel(self) -> bool: 
-        if not self._interceptors_task.done(): 
-            # There is no yet the intercepted call available, 
-            # Trying to cancel it by using the generic Asyncio 
-            # cancellation method. 
-            return self._interceptors_task.cancel() 
- 
-        try: 
-            call = self._interceptors_task.result() 
-        except AioRpcError: 
-            return False 
-        except asyncio.CancelledError: 
-            return False 
- 
-        return call.cancel() 
- 
-    def cancelled(self) -> bool: 
-        if not self._interceptors_task.done(): 
-            return False 
- 
-        try: 
-            call = self._interceptors_task.result() 
-        except AioRpcError as err: 
-            return err.code() == grpc.StatusCode.CANCELLED 
-        except asyncio.CancelledError: 
-            return True 
- 
-        return call.cancelled() 
- 
-    def done(self) -> bool: 
-        if not self._interceptors_task.done(): 
-            return False 
- 
-        try: 
-            call = self._interceptors_task.result() 
-        except (AioRpcError, asyncio.CancelledError): 
-            return True 
- 
-        return call.done() 
- 
-    def add_done_callback(self, callback: DoneCallbackType) -> None: 
-        if not self._interceptors_task.done(): 
-            self._pending_add_done_callbacks.append(callback) 
-            return 
- 
-        try: 
-            call = self._interceptors_task.result() 
-        except (AioRpcError, asyncio.CancelledError): 
-            callback(self) 
-            return 
- 
-        if call.done(): 
-            callback(self) 
-        else: 
-            callback = functools.partial(self._wrap_add_done_callback, callback) 
-            call.add_done_callback(callback) 
- 
-    def time_remaining(self) -> Optional[float]: 
-        raise NotImplementedError() 
- 
-    async def initial_metadata(self) -> Optional[Metadata]: 
-        try: 
-            call = await self._interceptors_task 
-        except AioRpcError as err: 
-            return err.initial_metadata() 
-        except asyncio.CancelledError: 
-            return None 
- 
-        return await call.initial_metadata() 
- 
-    async def trailing_metadata(self) -> Optional[Metadata]: 
-        try: 
-            call = await self._interceptors_task 
-        except AioRpcError as err: 
-            return err.trailing_metadata() 
-        except asyncio.CancelledError: 
-            return None 
- 
-        return await call.trailing_metadata() 
- 
-    async def code(self) -> grpc.StatusCode: 
-        try: 
-            call = await self._interceptors_task 
-        except AioRpcError as err: 
-            return err.code() 
-        except asyncio.CancelledError: 
-            return grpc.StatusCode.CANCELLED 
- 
-        return await call.code() 
- 
-    async def details(self) -> str: 
-        try: 
-            call = await self._interceptors_task 
-        except AioRpcError as err: 
-            return err.details() 
-        except asyncio.CancelledError: 
-            return _LOCAL_CANCELLATION_DETAILS 
- 
-        return await call.details() 
- 
-    async def debug_error_string(self) -> Optional[str]: 
-        try: 
-            call = await self._interceptors_task 
-        except AioRpcError as err: 
-            return err.debug_error_string() 
-        except asyncio.CancelledError: 
-            return '' 
- 
-        return await call.debug_error_string() 
- 
-    async def wait_for_connection(self) -> None: 
-        call = await self._interceptors_task 
-        return await call.wait_for_connection() 
- 
- 
-class _InterceptedUnaryResponseMixin: 
- 
-    def __await__(self): 
-        call = yield from self._interceptors_task.__await__() 
-        response = yield from call.__await__() 
-        return response 
- 
- 
-class _InterceptedStreamResponseMixin: 
-    _response_aiter: Optional[AsyncIterable[ResponseType]] 
- 
-    def _init_stream_response_mixin(self) -> None: 
-        # Is initalized later, otherwise if the iterator is not finnally 
-        # consumed a logging warning is emmited by Asyncio. 
-        self._response_aiter = None 
- 
-    async def _wait_for_interceptor_task_response_iterator(self 
-                                                          ) -> ResponseType: 
-        call = await self._interceptors_task 
-        async for response in call: 
-            yield response 
- 
-    def __aiter__(self) -> AsyncIterable[ResponseType]: 
-        if self._response_aiter is None: 
-            self._response_aiter = self._wait_for_interceptor_task_response_iterator( 
-            ) 
-        return self._response_aiter 
- 
-    async def read(self) -> ResponseType: 
-        if self._response_aiter is None: 
-            self._response_aiter = self._wait_for_interceptor_task_response_iterator( 
-            ) 
-        return await self._response_aiter.asend(None) 
- 
- 
-class _InterceptedStreamRequestMixin: 
- 
-    _write_to_iterator_async_gen: Optional[AsyncIterable[RequestType]] 
-    _write_to_iterator_queue: Optional[asyncio.Queue] 
- 
-    _FINISH_ITERATOR_SENTINEL = object() 
- 
-    def _init_stream_request_mixin( 
-            self, request_iterator: Optional[RequestIterableType] 
-    ) -> RequestIterableType: 
- 
-        if request_iterator is None: 
-            # We provide our own request iterator which is a proxy 
-            # of the futures writes that will be done by the caller. 
-            self._write_to_iterator_queue = asyncio.Queue(maxsize=1) 
-            self._write_to_iterator_async_gen = self._proxy_writes_as_request_iterator( 
-            ) 
-            request_iterator = self._write_to_iterator_async_gen 
-        else: 
-            self._write_to_iterator_queue = None 
- 
-        return request_iterator 
- 
-    async def _proxy_writes_as_request_iterator(self): 
-        await self._interceptors_task 
- 
-        while True: 
-            value = await self._write_to_iterator_queue.get() 
-            if value is _InterceptedStreamRequestMixin._FINISH_ITERATOR_SENTINEL: 
-                break 
-            yield value 
- 
-    async def write(self, request: RequestType) -> None: 
-        # If no queue was created it means that requests 
-        # should be expected through an iterators provided 
-        # by the caller. 
-        if self._write_to_iterator_queue is None: 
-            raise cygrpc.UsageError(_API_STYLE_ERROR) 
- 
-        try: 
-            call = await self._interceptors_task 
-        except (asyncio.CancelledError, AioRpcError): 
-            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS) 
- 
-        if call.done(): 
-            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS) 
-        elif call._done_writing_flag: 
-            raise asyncio.InvalidStateError(_RPC_HALF_CLOSED_DETAILS) 
- 
-        # Write might never end up since the call could abrubtly finish, 
-        # we give up on the first awaitable object that finishes. 
-        _, _ = await asyncio.wait( 
-            (self._write_to_iterator_queue.put(request), call.code()), 
-            return_when=asyncio.FIRST_COMPLETED) 
- 
-        if call.done(): 
-            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS) 
- 
-    async def done_writing(self) -> None: 
-        """Signal peer that client is done writing. 
- 
-        This method is idempotent. 
-        """ 
-        # If no queue was created it means that requests 
-        # should be expected through an iterators provided 
-        # by the caller. 
-        if self._write_to_iterator_queue is None: 
-            raise cygrpc.UsageError(_API_STYLE_ERROR) 
- 
-        try: 
-            call = await self._interceptors_task 
-        except asyncio.CancelledError: 
-            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS) 
- 
-        # Write might never end up since the call could abrubtly finish, 
-        # we give up on the first awaitable object that finishes. 
-        _, _ = await asyncio.wait((self._write_to_iterator_queue.put( 
-            _InterceptedStreamRequestMixin._FINISH_ITERATOR_SENTINEL), 
-                                   call.code()), 
-                                  return_when=asyncio.FIRST_COMPLETED) 
- 
- 
-class InterceptedUnaryUnaryCall(_InterceptedUnaryResponseMixin, InterceptedCall, 
-                                _base_call.UnaryUnaryCall): 
-    """Used for running a `UnaryUnaryCall` wrapped by interceptors. 
- 
-    For the `__await__` method is it is proxied to the intercepted call only when 
-    the interceptor task is finished. 
-    """ 
- 
-    _loop: asyncio.AbstractEventLoop 
-    _channel: cygrpc.AioChannel 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__(self, interceptors: Sequence[UnaryUnaryClientInterceptor], 
-                 request: RequestType, timeout: Optional[float], 
-                 metadata: Metadata, 
-                 credentials: Optional[grpc.CallCredentials], 
-                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel, 
-                 method: bytes, request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        self._loop = loop 
-        self._channel = channel 
-        interceptors_task = loop.create_task( 
-            self._invoke(interceptors, method, timeout, metadata, credentials, 
-                         wait_for_ready, request, request_serializer, 
-                         response_deserializer)) 
-        super().__init__(interceptors_task) 
- 
-    # pylint: disable=too-many-arguments 
-    async def _invoke(self, interceptors: Sequence[UnaryUnaryClientInterceptor], 
-                      method: bytes, timeout: Optional[float], 
-                      metadata: Optional[Metadata], 
-                      credentials: Optional[grpc.CallCredentials], 
-                      wait_for_ready: Optional[bool], request: RequestType, 
-                      request_serializer: SerializingFunction, 
-                      response_deserializer: DeserializingFunction 
-                     ) -> UnaryUnaryCall: 
-        """Run the RPC call wrapped in interceptors""" 
- 
-        async def _run_interceptor( 
-                interceptors: Iterator[UnaryUnaryClientInterceptor], 
-                client_call_details: ClientCallDetails, 
-                request: RequestType) -> _base_call.UnaryUnaryCall: 
- 
-            interceptor = next(interceptors, None) 
- 
-            if interceptor: 
-                continuation = functools.partial(_run_interceptor, interceptors) 
- 
-                call_or_response = await interceptor.intercept_unary_unary( 
-                    continuation, client_call_details, request) 
- 
-                if isinstance(call_or_response, _base_call.UnaryUnaryCall): 
-                    return call_or_response 
-                else: 
-                    return UnaryUnaryCallResponse(call_or_response) 
- 
-            else: 
-                return UnaryUnaryCall( 
-                    request, _timeout_to_deadline(client_call_details.timeout), 
-                    client_call_details.metadata, 
-                    client_call_details.credentials, 
-                    client_call_details.wait_for_ready, self._channel, 
-                    client_call_details.method, request_serializer, 
-                    response_deserializer, self._loop) 
- 
-        client_call_details = ClientCallDetails(method, timeout, metadata, 
-                                                credentials, wait_for_ready) 
-        return await _run_interceptor(iter(interceptors), client_call_details, 
-                                      request) 
- 
-    def time_remaining(self) -> Optional[float]: 
-        raise NotImplementedError() 
- 
- 
-class InterceptedUnaryStreamCall(_InterceptedStreamResponseMixin, 
-                                 InterceptedCall, _base_call.UnaryStreamCall): 
-    """Used for running a `UnaryStreamCall` wrapped by interceptors.""" 
- 
-    _loop: asyncio.AbstractEventLoop 
-    _channel: cygrpc.AioChannel 
-    _last_returned_call_from_interceptors = Optional[_base_call.UnaryStreamCall] 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__(self, interceptors: Sequence[UnaryStreamClientInterceptor], 
-                 request: RequestType, timeout: Optional[float], 
-                 metadata: Metadata, 
-                 credentials: Optional[grpc.CallCredentials], 
-                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel, 
-                 method: bytes, request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        self._loop = loop 
-        self._channel = channel 
-        self._init_stream_response_mixin() 
-        self._last_returned_call_from_interceptors = None 
-        interceptors_task = loop.create_task( 
-            self._invoke(interceptors, method, timeout, metadata, credentials, 
-                         wait_for_ready, request, request_serializer, 
-                         response_deserializer)) 
-        super().__init__(interceptors_task) 
- 
-    # pylint: disable=too-many-arguments 
-    async def _invoke(self, interceptors: Sequence[UnaryUnaryClientInterceptor], 
-                      method: bytes, timeout: Optional[float], 
-                      metadata: Optional[Metadata], 
-                      credentials: Optional[grpc.CallCredentials], 
-                      wait_for_ready: Optional[bool], request: RequestType, 
-                      request_serializer: SerializingFunction, 
-                      response_deserializer: DeserializingFunction 
-                     ) -> UnaryStreamCall: 
-        """Run the RPC call wrapped in interceptors""" 
- 
-        async def _run_interceptor( 
-                interceptors: Iterator[UnaryStreamClientInterceptor], 
-                client_call_details: ClientCallDetails, 
-                request: RequestType, 
-        ) -> _base_call.UnaryUnaryCall: 
- 
-            interceptor = next(interceptors, None) 
- 
-            if interceptor: 
-                continuation = functools.partial(_run_interceptor, interceptors) 
- 
-                call_or_response_iterator = await interceptor.intercept_unary_stream( 
-                    continuation, client_call_details, request) 
- 
-                if isinstance(call_or_response_iterator, 
-                              _base_call.UnaryStreamCall): 
-                    self._last_returned_call_from_interceptors = call_or_response_iterator 
-                else: 
-                    self._last_returned_call_from_interceptors = UnaryStreamCallResponseIterator( 
-                        self._last_returned_call_from_interceptors, 
-                        call_or_response_iterator) 
-                return self._last_returned_call_from_interceptors 
-            else: 
-                self._last_returned_call_from_interceptors = UnaryStreamCall( 
-                    request, _timeout_to_deadline(client_call_details.timeout), 
-                    client_call_details.metadata, 
-                    client_call_details.credentials, 
-                    client_call_details.wait_for_ready, self._channel, 
-                    client_call_details.method, request_serializer, 
-                    response_deserializer, self._loop) 
- 
-                return self._last_returned_call_from_interceptors 
- 
-        client_call_details = ClientCallDetails(method, timeout, metadata, 
-                                                credentials, wait_for_ready) 
-        return await _run_interceptor(iter(interceptors), client_call_details, 
-                                      request) 
- 
-    def time_remaining(self) -> Optional[float]: 
-        raise NotImplementedError() 
- 
- 
-class InterceptedStreamUnaryCall(_InterceptedUnaryResponseMixin, 
-                                 _InterceptedStreamRequestMixin, 
-                                 InterceptedCall, _base_call.StreamUnaryCall): 
-    """Used for running a `StreamUnaryCall` wrapped by interceptors. 
- 
-    For the `__await__` method is it is proxied to the intercepted call only when 
-    the interceptor task is finished. 
-    """ 
- 
-    _loop: asyncio.AbstractEventLoop 
-    _channel: cygrpc.AioChannel 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__(self, interceptors: Sequence[StreamUnaryClientInterceptor], 
-                 request_iterator: Optional[RequestIterableType], 
-                 timeout: Optional[float], metadata: Metadata, 
-                 credentials: Optional[grpc.CallCredentials], 
-                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel, 
-                 method: bytes, request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        self._loop = loop 
-        self._channel = channel 
-        request_iterator = self._init_stream_request_mixin(request_iterator) 
-        interceptors_task = loop.create_task( 
-            self._invoke(interceptors, method, timeout, metadata, credentials, 
-                         wait_for_ready, request_iterator, request_serializer, 
-                         response_deserializer)) 
-        super().__init__(interceptors_task) 
- 
-    # pylint: disable=too-many-arguments 
-    async def _invoke( 
-            self, interceptors: Sequence[StreamUnaryClientInterceptor], 
-            method: bytes, timeout: Optional[float], 
-            metadata: Optional[Metadata], 
-            credentials: Optional[grpc.CallCredentials], 
-            wait_for_ready: Optional[bool], 
-            request_iterator: RequestIterableType, 
-            request_serializer: SerializingFunction, 
-            response_deserializer: DeserializingFunction) -> StreamUnaryCall: 
-        """Run the RPC call wrapped in interceptors""" 
- 
-        async def _run_interceptor( 
-                interceptors: Iterator[UnaryUnaryClientInterceptor], 
-                client_call_details: ClientCallDetails, 
-                request_iterator: RequestIterableType 
-        ) -> _base_call.StreamUnaryCall: 
- 
-            interceptor = next(interceptors, None) 
- 
-            if interceptor: 
-                continuation = functools.partial(_run_interceptor, interceptors) 
- 
-                return await interceptor.intercept_stream_unary( 
-                    continuation, client_call_details, request_iterator) 
-            else: 
-                return StreamUnaryCall( 
-                    request_iterator, 
-                    _timeout_to_deadline(client_call_details.timeout), 
-                    client_call_details.metadata, 
-                    client_call_details.credentials, 
-                    client_call_details.wait_for_ready, self._channel, 
-                    client_call_details.method, request_serializer, 
-                    response_deserializer, self._loop) 
- 
-        client_call_details = ClientCallDetails(method, timeout, metadata, 
-                                                credentials, wait_for_ready) 
-        return await _run_interceptor(iter(interceptors), client_call_details, 
-                                      request_iterator) 
- 
-    def time_remaining(self) -> Optional[float]: 
-        raise NotImplementedError() 
- 
- 
-class InterceptedStreamStreamCall(_InterceptedStreamResponseMixin, 
-                                  _InterceptedStreamRequestMixin, 
-                                  InterceptedCall, _base_call.StreamStreamCall): 
-    """Used for running a `StreamStreamCall` wrapped by interceptors.""" 
- 
-    _loop: asyncio.AbstractEventLoop 
-    _channel: cygrpc.AioChannel 
-    _last_returned_call_from_interceptors = Optional[_base_call.UnaryStreamCall] 
- 
-    # pylint: disable=too-many-arguments 
-    def __init__(self, interceptors: Sequence[StreamStreamClientInterceptor], 
-                 request_iterator: Optional[RequestIterableType], 
-                 timeout: Optional[float], metadata: Metadata, 
-                 credentials: Optional[grpc.CallCredentials], 
-                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel, 
-                 method: bytes, request_serializer: SerializingFunction, 
-                 response_deserializer: DeserializingFunction, 
-                 loop: asyncio.AbstractEventLoop) -> None: 
-        self._loop = loop 
-        self._channel = channel 
-        self._init_stream_response_mixin() 
-        request_iterator = self._init_stream_request_mixin(request_iterator) 
-        self._last_returned_call_from_interceptors = None 
-        interceptors_task = loop.create_task( 
-            self._invoke(interceptors, method, timeout, metadata, credentials, 
-                         wait_for_ready, request_iterator, request_serializer, 
-                         response_deserializer)) 
-        super().__init__(interceptors_task) 
- 
-    # pylint: disable=too-many-arguments 
-    async def _invoke( 
-            self, interceptors: Sequence[StreamStreamClientInterceptor], 
-            method: bytes, timeout: Optional[float], 
-            metadata: Optional[Metadata], 
-            credentials: Optional[grpc.CallCredentials], 
-            wait_for_ready: Optional[bool], 
-            request_iterator: RequestIterableType, 
-            request_serializer: SerializingFunction, 
-            response_deserializer: DeserializingFunction) -> StreamStreamCall: 
-        """Run the RPC call wrapped in interceptors""" 
- 
-        async def _run_interceptor( 
-                interceptors: Iterator[StreamStreamClientInterceptor], 
-                client_call_details: ClientCallDetails, 
-                request_iterator: RequestIterableType 
-        ) -> _base_call.StreamStreamCall: 
- 
-            interceptor = next(interceptors, None) 
- 
-            if interceptor: 
-                continuation = functools.partial(_run_interceptor, interceptors) 
- 
-                call_or_response_iterator = await interceptor.intercept_stream_stream( 
-                    continuation, client_call_details, request_iterator) 
- 
-                if isinstance(call_or_response_iterator, 
-                              _base_call.StreamStreamCall): 
-                    self._last_returned_call_from_interceptors = call_or_response_iterator 
-                else: 
-                    self._last_returned_call_from_interceptors = StreamStreamCallResponseIterator( 
-                        self._last_returned_call_from_interceptors, 
-                        call_or_response_iterator) 
-                return self._last_returned_call_from_interceptors 
-            else: 
-                self._last_returned_call_from_interceptors = StreamStreamCall( 
-                    request_iterator, 
-                    _timeout_to_deadline(client_call_details.timeout), 
-                    client_call_details.metadata, 
-                    client_call_details.credentials, 
-                    client_call_details.wait_for_ready, self._channel, 
-                    client_call_details.method, request_serializer, 
-                    response_deserializer, self._loop) 
-                return self._last_returned_call_from_interceptors 
- 
-        client_call_details = ClientCallDetails(method, timeout, metadata, 
-                                                credentials, wait_for_ready) 
-        return await _run_interceptor(iter(interceptors), client_call_details, 
-                                      request_iterator) 
- 
-    def time_remaining(self) -> Optional[float]: 
-        raise NotImplementedError() 
- 
- 
-class UnaryUnaryCallResponse(_base_call.UnaryUnaryCall): 
-    """Final UnaryUnaryCall class finished with a response.""" 
-    _response: ResponseType 
- 
-    def __init__(self, response: ResponseType) -> None: 
-        self._response = response 
- 
-    def cancel(self) -> bool: 
-        return False 
- 
-    def cancelled(self) -> bool: 
-        return False 
- 
-    def done(self) -> bool: 
-        return True 
- 
-    def add_done_callback(self, unused_callback) -> None: 
-        raise NotImplementedError() 
- 
-    def time_remaining(self) -> Optional[float]: 
-        raise NotImplementedError() 
- 
-    async def initial_metadata(self) -> Optional[Metadata]: 
-        return None 
- 
-    async def trailing_metadata(self) -> Optional[Metadata]: 
-        return None 
- 
-    async def code(self) -> grpc.StatusCode: 
-        return grpc.StatusCode.OK 
- 
-    async def details(self) -> str: 
-        return '' 
- 
-    async def debug_error_string(self) -> Optional[str]: 
-        return None 
- 
-    def __await__(self): 
-        if False:  # pylint: disable=using-constant-test 
-            # This code path is never used, but a yield statement is needed 
-            # for telling the interpreter that __await__ is a generator. 
-            yield None 
-        return self._response 
- 
-    async def wait_for_connection(self) -> None: 
-        pass 
- 
- 
-class _StreamCallResponseIterator: 
- 
-    _call: Union[_base_call.UnaryStreamCall, _base_call.StreamStreamCall] 
-    _response_iterator: AsyncIterable[ResponseType] 
- 
-    def __init__(self, call: Union[_base_call.UnaryStreamCall, _base_call. 
-                                   StreamStreamCall], 
-                 response_iterator: AsyncIterable[ResponseType]) -> None: 
-        self._response_iterator = response_iterator 
-        self._call = call 
- 
-    def cancel(self) -> bool: 
-        return self._call.cancel() 
- 
-    def cancelled(self) -> bool: 
-        return self._call.cancelled() 
- 
-    def done(self) -> bool: 
-        return self._call.done() 
- 
-    def add_done_callback(self, callback) -> None: 
-        self._call.add_done_callback(callback) 
- 
-    def time_remaining(self) -> Optional[float]: 
-        return self._call.time_remaining() 
- 
-    async def initial_metadata(self) -> Optional[Metadata]: 
-        return await self._call.initial_metadata() 
- 
-    async def trailing_metadata(self) -> Optional[Metadata]: 
-        return await self._call.trailing_metadata() 
- 
-    async def code(self) -> grpc.StatusCode: 
-        return await self._call.code() 
- 
-    async def details(self) -> str: 
-        return await self._call.details() 
- 
-    async def debug_error_string(self) -> Optional[str]: 
-        return await self._call.debug_error_string() 
- 
-    def __aiter__(self): 
-        return self._response_iterator.__aiter__() 
- 
-    async def wait_for_connection(self) -> None: 
-        return await self._call.wait_for_connection() 
- 
- 
-class UnaryStreamCallResponseIterator(_StreamCallResponseIterator, 
-                                      _base_call.UnaryStreamCall): 
-    """UnaryStreamCall class wich uses an alternative response iterator.""" 
- 
-    async def read(self) -> ResponseType: 
-        # Behind the scenes everyting goes through the 
-        # async iterator. So this path should not be reached. 
-        raise NotImplementedError() 
- 
- 
-class StreamStreamCallResponseIterator(_StreamCallResponseIterator, 
-                                       _base_call.StreamStreamCall): 
-    """StreamStreamCall class wich uses an alternative response iterator.""" 
- 
-    async def read(self) -> ResponseType: 
-        # Behind the scenes everyting goes through the 
-        # async iterator. So this path should not be reached. 
-        raise NotImplementedError() 
- 
-    async def write(self, request: RequestType) -> None: 
-        # Behind the scenes everyting goes through the 
-        # async iterator provided by the InterceptedStreamStreamCall. 
-        # So this path should not be reached. 
-        raise NotImplementedError() 
- 
-    async def done_writing(self) -> None: 
-        # Behind the scenes everyting goes through the 
-        # async iterator provided by the InterceptedStreamStreamCall. 
-        # So this path should not be reached. 
-        raise NotImplementedError() 
- 
-    @property 
-    def _done_writing_flag(self) -> bool: 
-        return self._call._done_writing_flag 
+# Copyright 2019 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Interceptors implementation of gRPC Asyncio Python."""
+import asyncio
+import collections
+import functools
+from abc import ABCMeta, abstractmethod
+from typing import Callable, Optional, Iterator, Sequence, Union, Awaitable, AsyncIterable
+
+import grpc
+from grpc._cython import cygrpc
+
+from . import _base_call
+from ._call import UnaryUnaryCall, UnaryStreamCall, StreamUnaryCall, StreamStreamCall, AioRpcError
+from ._call import _RPC_ALREADY_FINISHED_DETAILS, _RPC_HALF_CLOSED_DETAILS
+from ._call import _API_STYLE_ERROR
+from ._utils import _timeout_to_deadline
+from ._typing import (RequestType, SerializingFunction, DeserializingFunction,
+                      ResponseType, DoneCallbackType, RequestIterableType,
+                      ResponseIterableType)
+from ._metadata import Metadata
+
+_LOCAL_CANCELLATION_DETAILS = 'Locally cancelled by application!'
+
+
+class ServerInterceptor(metaclass=ABCMeta):
+    """Affords intercepting incoming RPCs on the service-side.
+
+    This is an EXPERIMENTAL API.
+    """
+
+    @abstractmethod
+    async def intercept_service(
+            self, continuation: Callable[[grpc.HandlerCallDetails], Awaitable[
+                grpc.RpcMethodHandler]],
+            handler_call_details: grpc.HandlerCallDetails
+    ) -> grpc.RpcMethodHandler:
+        """Intercepts incoming RPCs before handing them over to a handler.
+
+        Args:
+            continuation: A function that takes a HandlerCallDetails and
+                proceeds to invoke the next interceptor in the chain, if any,
+                or the RPC handler lookup logic, with the call details passed
+                as an argument, and returns an RpcMethodHandler instance if
+                the RPC is considered serviced, or None otherwise.
+            handler_call_details: A HandlerCallDetails describing the RPC.
+
+        Returns:
+            An RpcMethodHandler with which the RPC may be serviced if the
+            interceptor chooses to service this RPC, or None otherwise.
+        """
+
+
+class ClientCallDetails(
+        collections.namedtuple(
+            'ClientCallDetails',
+            ('method', 'timeout', 'metadata', 'credentials', 'wait_for_ready')),
+        grpc.ClientCallDetails):
+    """Describes an RPC to be invoked.
+
+    This is an EXPERIMENTAL API.
+
+    Args:
+        method: The method name of the RPC.
+        timeout: An optional duration of time in seconds to allow for the RPC.
+        metadata: Optional metadata to be transmitted to the service-side of
+          the RPC.
+        credentials: An optional CallCredentials for the RPC.
+        wait_for_ready: This is an EXPERIMENTAL argument. An optional
+            flag to enable :term:`wait_for_ready` mechanism.
+    """
+
+    method: str
+    timeout: Optional[float]
+    metadata: Optional[Metadata]
+    credentials: Optional[grpc.CallCredentials]
+    wait_for_ready: Optional[bool]
+
+
+class ClientInterceptor(metaclass=ABCMeta):
+    """Base class used for all Aio Client Interceptor classes"""
+
+
+class UnaryUnaryClientInterceptor(ClientInterceptor, metaclass=ABCMeta):
+    """Affords intercepting unary-unary invocations."""
+
+    @abstractmethod
+    async def intercept_unary_unary(
+            self, continuation: Callable[[ClientCallDetails, RequestType],
+                                         UnaryUnaryCall],
+            client_call_details: ClientCallDetails,
+            request: RequestType) -> Union[UnaryUnaryCall, ResponseType]:
+        """Intercepts a unary-unary invocation asynchronously.
+
+        Args:
+          continuation: A coroutine that proceeds with the invocation by
+            executing the next interceptor in the chain or invoking the
+            actual RPC on the underlying Channel. It is the interceptor's
+            responsibility to call it if it decides to move the RPC forward.
+            The interceptor can use
+            `call = await continuation(client_call_details, request)`
+            to continue with the RPC. `continuation` returns the call to the
+            RPC.
+          client_call_details: A ClientCallDetails object describing the
+            outgoing RPC.
+          request: The request value for the RPC.
+
+        Returns:
+          An object with the RPC response.
+
+        Raises:
+          AioRpcError: Indicating that the RPC terminated with non-OK status.
+          asyncio.CancelledError: Indicating that the RPC was canceled.
+        """
+
+
+class UnaryStreamClientInterceptor(ClientInterceptor, metaclass=ABCMeta):
+    """Affords intercepting unary-stream invocations."""
+
+    @abstractmethod
+    async def intercept_unary_stream(
+            self, continuation: Callable[[ClientCallDetails, RequestType],
+                                         UnaryStreamCall],
+            client_call_details: ClientCallDetails, request: RequestType
+    ) -> Union[ResponseIterableType, UnaryStreamCall]:
+        """Intercepts a unary-stream invocation asynchronously.
+
+        The function could return the call object or an asynchronous
+        iterator, in case of being an asyncrhonous iterator this will
+        become the source of the reads done by the caller.
+
+        Args:
+          continuation: A coroutine that proceeds with the invocation by
+            executing the next interceptor in the chain or invoking the
+            actual RPC on the underlying Channel. It is the interceptor's
+            responsibility to call it if it decides to move the RPC forward.
+            The interceptor can use
+            `call = await continuation(client_call_details, request)`
+            to continue with the RPC. `continuation` returns the call to the
+            RPC.
+          client_call_details: A ClientCallDetails object describing the
+            outgoing RPC.
+          request: The request value for the RPC.
+
+        Returns:
+          The RPC Call or an asynchronous iterator.
+
+        Raises:
+          AioRpcError: Indicating that the RPC terminated with non-OK status.
+          asyncio.CancelledError: Indicating that the RPC was canceled.
+        """
+
+
+class StreamUnaryClientInterceptor(ClientInterceptor, metaclass=ABCMeta):
+    """Affords intercepting stream-unary invocations."""
+
+    @abstractmethod
+    async def intercept_stream_unary(
+            self,
+            continuation: Callable[[ClientCallDetails, RequestType],
+                                   UnaryStreamCall],
+            client_call_details: ClientCallDetails,
+            request_iterator: RequestIterableType,
+    ) -> StreamUnaryCall:
+        """Intercepts a stream-unary invocation asynchronously.
+
+        Within the interceptor the usage of the call methods like `write` or
+        even awaiting the call should be done carefully, since the caller
+        could be expecting an untouched call, for example for start writing
+        messages to it.
+
+        Args:
+          continuation: A coroutine that proceeds with the invocation by
+            executing the next interceptor in the chain or invoking the
+            actual RPC on the underlying Channel. It is the interceptor's
+            responsibility to call it if it decides to move the RPC forward.
+            The interceptor can use
+            `call = await continuation(client_call_details, request_iterator)`
+            to continue with the RPC. `continuation` returns the call to the
+            RPC.
+          client_call_details: A ClientCallDetails object describing the
+            outgoing RPC.
+          request_iterator: The request iterator that will produce requests
+            for the RPC.
+
+        Returns:
+          The RPC Call.
+
+        Raises:
+          AioRpcError: Indicating that the RPC terminated with non-OK status.
+          asyncio.CancelledError: Indicating that the RPC was canceled.
+        """
+
+
+class StreamStreamClientInterceptor(ClientInterceptor, metaclass=ABCMeta):
+    """Affords intercepting stream-stream invocations."""
+
+    @abstractmethod
+    async def intercept_stream_stream(
+            self,
+            continuation: Callable[[ClientCallDetails, RequestType],
+                                   UnaryStreamCall],
+            client_call_details: ClientCallDetails,
+            request_iterator: RequestIterableType,
+    ) -> Union[ResponseIterableType, StreamStreamCall]:
+        """Intercepts a stream-stream invocation asynchronously.
+
+        Within the interceptor the usage of the call methods like `write` or
+        even awaiting the call should be done carefully, since the caller
+        could be expecting an untouched call, for example for start writing
+        messages to it.
+
+        The function could return the call object or an asynchronous
+        iterator, in case of being an asyncrhonous iterator this will
+        become the source of the reads done by the caller.
+
+        Args:
+          continuation: A coroutine that proceeds with the invocation by
+            executing the next interceptor in the chain or invoking the
+            actual RPC on the underlying Channel. It is the interceptor's
+            responsibility to call it if it decides to move the RPC forward.
+            The interceptor can use
+            `call = await continuation(client_call_details, request_iterator)`
+            to continue with the RPC. `continuation` returns the call to the
+            RPC.
+          client_call_details: A ClientCallDetails object describing the
+            outgoing RPC.
+          request_iterator: The request iterator that will produce requests
+            for the RPC.
+
+        Returns:
+          The RPC Call or an asynchronous iterator.
+
+        Raises:
+          AioRpcError: Indicating that the RPC terminated with non-OK status.
+          asyncio.CancelledError: Indicating that the RPC was canceled.
+        """
+
+
+class InterceptedCall:
+    """Base implementation for all intercepted call arities.
+
+    Interceptors might have some work to do before the RPC invocation with
+    the capacity of changing the invocation parameters, and some work to do
+    after the RPC invocation with the capacity for accessing to the wrapped
+    `UnaryUnaryCall`.
+
+    It handles also early and later cancellations, when the RPC has not even
+    started and the execution is still held by the interceptors or when the
+    RPC has finished but again the execution is still held by the interceptors.
+
+    Once the RPC is finally executed, all methods are finally done against the
+    intercepted call, being at the same time the same call returned to the
+    interceptors.
+
+    As a base class for all of the interceptors implements the logic around
+    final status, metadata and cancellation.
+    """
+
+    _interceptors_task: asyncio.Task
+    _pending_add_done_callbacks: Sequence[DoneCallbackType]
+
+    def __init__(self, interceptors_task: asyncio.Task) -> None:
+        self._interceptors_task = interceptors_task
+        self._pending_add_done_callbacks = []
+        self._interceptors_task.add_done_callback(
+            self._fire_or_add_pending_done_callbacks)
+
+    def __del__(self):
+        self.cancel()
+
+    def _fire_or_add_pending_done_callbacks(self,
+                                            interceptors_task: asyncio.Task
+                                           ) -> None:
+
+        if not self._pending_add_done_callbacks:
+            return
+
+        call_completed = False
+
+        try:
+            call = interceptors_task.result()
+            if call.done():
+                call_completed = True
+        except (AioRpcError, asyncio.CancelledError):
+            call_completed = True
+
+        if call_completed:
+            for callback in self._pending_add_done_callbacks:
+                callback(self)
+        else:
+            for callback in self._pending_add_done_callbacks:
+                callback = functools.partial(self._wrap_add_done_callback,
+                                             callback)
+                call.add_done_callback(callback)
+
+        self._pending_add_done_callbacks = []
+
+    def _wrap_add_done_callback(self, callback: DoneCallbackType,
+                                unused_call: _base_call.Call) -> None:
+        callback(self)
+
+    def cancel(self) -> bool:
+        if not self._interceptors_task.done():
+            # There is no yet the intercepted call available,
+            # Trying to cancel it by using the generic Asyncio
+            # cancellation method.
+            return self._interceptors_task.cancel()
+
+        try:
+            call = self._interceptors_task.result()
+        except AioRpcError:
+            return False
+        except asyncio.CancelledError:
+            return False
+
+        return call.cancel()
+
+    def cancelled(self) -> bool:
+        if not self._interceptors_task.done():
+            return False
+
+        try:
+            call = self._interceptors_task.result()
+        except AioRpcError as err:
+            return err.code() == grpc.StatusCode.CANCELLED
+        except asyncio.CancelledError:
+            return True
+
+        return call.cancelled()
+
+    def done(self) -> bool:
+        if not self._interceptors_task.done():
+            return False
+
+        try:
+            call = self._interceptors_task.result()
+        except (AioRpcError, asyncio.CancelledError):
+            return True
+
+        return call.done()
+
+    def add_done_callback(self, callback: DoneCallbackType) -> None:
+        if not self._interceptors_task.done():
+            self._pending_add_done_callbacks.append(callback)
+            return
+
+        try:
+            call = self._interceptors_task.result()
+        except (AioRpcError, asyncio.CancelledError):
+            callback(self)
+            return
+
+        if call.done():
+            callback(self)
+        else:
+            callback = functools.partial(self._wrap_add_done_callback, callback)
+            call.add_done_callback(callback)
+
+    def time_remaining(self) -> Optional[float]:
+        raise NotImplementedError()
+
+    async def initial_metadata(self) -> Optional[Metadata]:
+        try:
+            call = await self._interceptors_task
+        except AioRpcError as err:
+            return err.initial_metadata()
+        except asyncio.CancelledError:
+            return None
+
+        return await call.initial_metadata()
+
+    async def trailing_metadata(self) -> Optional[Metadata]:
+        try:
+            call = await self._interceptors_task
+        except AioRpcError as err:
+            return err.trailing_metadata()
+        except asyncio.CancelledError:
+            return None
+
+        return await call.trailing_metadata()
+
+    async def code(self) -> grpc.StatusCode:
+        try:
+            call = await self._interceptors_task
+        except AioRpcError as err:
+            return err.code()
+        except asyncio.CancelledError:
+            return grpc.StatusCode.CANCELLED
+
+        return await call.code()
+
+    async def details(self) -> str:
+        try:
+            call = await self._interceptors_task
+        except AioRpcError as err:
+            return err.details()
+        except asyncio.CancelledError:
+            return _LOCAL_CANCELLATION_DETAILS
+
+        return await call.details()
+
+    async def debug_error_string(self) -> Optional[str]:
+        try:
+            call = await self._interceptors_task
+        except AioRpcError as err:
+            return err.debug_error_string()
+        except asyncio.CancelledError:
+            return ''
+
+        return await call.debug_error_string()
+
+    async def wait_for_connection(self) -> None:
+        call = await self._interceptors_task
+        return await call.wait_for_connection()
+
+
+class _InterceptedUnaryResponseMixin:
+
+    def __await__(self):
+        call = yield from self._interceptors_task.__await__()
+        response = yield from call.__await__()
+        return response
+
+
+class _InterceptedStreamResponseMixin:
+    _response_aiter: Optional[AsyncIterable[ResponseType]]
+
+    def _init_stream_response_mixin(self) -> None:
+        # Is initalized later, otherwise if the iterator is not finnally
+        # consumed a logging warning is emmited by Asyncio.
+        self._response_aiter = None
+
+    async def _wait_for_interceptor_task_response_iterator(self
+                                                          ) -> ResponseType:
+        call = await self._interceptors_task
+        async for response in call:
+            yield response
+
+    def __aiter__(self) -> AsyncIterable[ResponseType]:
+        if self._response_aiter is None:
+            self._response_aiter = self._wait_for_interceptor_task_response_iterator(
+            )
+        return self._response_aiter
+
+    async def read(self) -> ResponseType:
+        if self._response_aiter is None:
+            self._response_aiter = self._wait_for_interceptor_task_response_iterator(
+            )
+        return await self._response_aiter.asend(None)
+
+
+class _InterceptedStreamRequestMixin:
+
+    _write_to_iterator_async_gen: Optional[AsyncIterable[RequestType]]
+    _write_to_iterator_queue: Optional[asyncio.Queue]
+
+    _FINISH_ITERATOR_SENTINEL = object()
+
+    def _init_stream_request_mixin(
+            self, request_iterator: Optional[RequestIterableType]
+    ) -> RequestIterableType:
+
+        if request_iterator is None:
+            # We provide our own request iterator which is a proxy
+            # of the futures writes that will be done by the caller.
+            self._write_to_iterator_queue = asyncio.Queue(maxsize=1)
+            self._write_to_iterator_async_gen = self._proxy_writes_as_request_iterator(
+            )
+            request_iterator = self._write_to_iterator_async_gen
+        else:
+            self._write_to_iterator_queue = None
+
+        return request_iterator
+
+    async def _proxy_writes_as_request_iterator(self):
+        await self._interceptors_task
+
+        while True:
+            value = await self._write_to_iterator_queue.get()
+            if value is _InterceptedStreamRequestMixin._FINISH_ITERATOR_SENTINEL:
+                break
+            yield value
+
+    async def write(self, request: RequestType) -> None:
+        # If no queue was created it means that requests
+        # should be expected through an iterators provided
+        # by the caller.
+        if self._write_to_iterator_queue is None:
+            raise cygrpc.UsageError(_API_STYLE_ERROR)
+
+        try:
+            call = await self._interceptors_task
+        except (asyncio.CancelledError, AioRpcError):
+            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
+
+        if call.done():
+            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
+        elif call._done_writing_flag:
+            raise asyncio.InvalidStateError(_RPC_HALF_CLOSED_DETAILS)
+
+        # Write might never end up since the call could abrubtly finish,
+        # we give up on the first awaitable object that finishes.
+        _, _ = await asyncio.wait(
+            (self._write_to_iterator_queue.put(request), call.code()),
+            return_when=asyncio.FIRST_COMPLETED)
+
+        if call.done():
+            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
+
+    async def done_writing(self) -> None:
+        """Signal peer that client is done writing.
+
+        This method is idempotent.
+        """
+        # If no queue was created it means that requests
+        # should be expected through an iterators provided
+        # by the caller.
+        if self._write_to_iterator_queue is None:
+            raise cygrpc.UsageError(_API_STYLE_ERROR)
+
+        try:
+            call = await self._interceptors_task
+        except asyncio.CancelledError:
+            raise asyncio.InvalidStateError(_RPC_ALREADY_FINISHED_DETAILS)
+
+        # Write might never end up since the call could abrubtly finish,
+        # we give up on the first awaitable object that finishes.
+        _, _ = await asyncio.wait((self._write_to_iterator_queue.put(
+            _InterceptedStreamRequestMixin._FINISH_ITERATOR_SENTINEL),
+                                   call.code()),
+                                  return_when=asyncio.FIRST_COMPLETED)
+
+
+class InterceptedUnaryUnaryCall(_InterceptedUnaryResponseMixin, InterceptedCall,
+                                _base_call.UnaryUnaryCall):
+    """Used for running a `UnaryUnaryCall` wrapped by interceptors.
+
+    For the `__await__` method is it is proxied to the intercepted call only when
+    the interceptor task is finished.
+    """
+
+    _loop: asyncio.AbstractEventLoop
+    _channel: cygrpc.AioChannel
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, interceptors: Sequence[UnaryUnaryClientInterceptor],
+                 request: RequestType, timeout: Optional[float],
+                 metadata: Metadata,
+                 credentials: Optional[grpc.CallCredentials],
+                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel,
+                 method: bytes, request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._channel = channel
+        interceptors_task = loop.create_task(
+            self._invoke(interceptors, method, timeout, metadata, credentials,
+                         wait_for_ready, request, request_serializer,
+                         response_deserializer))
+        super().__init__(interceptors_task)
+
+    # pylint: disable=too-many-arguments
+    async def _invoke(self, interceptors: Sequence[UnaryUnaryClientInterceptor],
+                      method: bytes, timeout: Optional[float],
+                      metadata: Optional[Metadata],
+                      credentials: Optional[grpc.CallCredentials],
+                      wait_for_ready: Optional[bool], request: RequestType,
+                      request_serializer: SerializingFunction,
+                      response_deserializer: DeserializingFunction
+                     ) -> UnaryUnaryCall:
+        """Run the RPC call wrapped in interceptors"""
+
+        async def _run_interceptor(
+                interceptors: Iterator[UnaryUnaryClientInterceptor],
+                client_call_details: ClientCallDetails,
+                request: RequestType) -> _base_call.UnaryUnaryCall:
+
+            interceptor = next(interceptors, None)
+
+            if interceptor:
+                continuation = functools.partial(_run_interceptor, interceptors)
+
+                call_or_response = await interceptor.intercept_unary_unary(
+                    continuation, client_call_details, request)
+
+                if isinstance(call_or_response, _base_call.UnaryUnaryCall):
+                    return call_or_response
+                else:
+                    return UnaryUnaryCallResponse(call_or_response)
+
+            else:
+                return UnaryUnaryCall(
+                    request, _timeout_to_deadline(client_call_details.timeout),
+                    client_call_details.metadata,
+                    client_call_details.credentials,
+                    client_call_details.wait_for_ready, self._channel,
+                    client_call_details.method, request_serializer,
+                    response_deserializer, self._loop)
+
+        client_call_details = ClientCallDetails(method, timeout, metadata,
+                                                credentials, wait_for_ready)
+        return await _run_interceptor(iter(interceptors), client_call_details,
+                                      request)
+
+    def time_remaining(self) -> Optional[float]:
+        raise NotImplementedError()
+
+
+class InterceptedUnaryStreamCall(_InterceptedStreamResponseMixin,
+                                 InterceptedCall, _base_call.UnaryStreamCall):
+    """Used for running a `UnaryStreamCall` wrapped by interceptors."""
+
+    _loop: asyncio.AbstractEventLoop
+    _channel: cygrpc.AioChannel
+    _last_returned_call_from_interceptors = Optional[_base_call.UnaryStreamCall]
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, interceptors: Sequence[UnaryStreamClientInterceptor],
+                 request: RequestType, timeout: Optional[float],
+                 metadata: Metadata,
+                 credentials: Optional[grpc.CallCredentials],
+                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel,
+                 method: bytes, request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._channel = channel
+        self._init_stream_response_mixin()
+        self._last_returned_call_from_interceptors = None
+        interceptors_task = loop.create_task(
+            self._invoke(interceptors, method, timeout, metadata, credentials,
+                         wait_for_ready, request, request_serializer,
+                         response_deserializer))
+        super().__init__(interceptors_task)
+
+    # pylint: disable=too-many-arguments
+    async def _invoke(self, interceptors: Sequence[UnaryUnaryClientInterceptor],
+                      method: bytes, timeout: Optional[float],
+                      metadata: Optional[Metadata],
+                      credentials: Optional[grpc.CallCredentials],
+                      wait_for_ready: Optional[bool], request: RequestType,
+                      request_serializer: SerializingFunction,
+                      response_deserializer: DeserializingFunction
+                     ) -> UnaryStreamCall:
+        """Run the RPC call wrapped in interceptors"""
+
+        async def _run_interceptor(
+                interceptors: Iterator[UnaryStreamClientInterceptor],
+                client_call_details: ClientCallDetails,
+                request: RequestType,
+        ) -> _base_call.UnaryUnaryCall:
+
+            interceptor = next(interceptors, None)
+
+            if interceptor:
+                continuation = functools.partial(_run_interceptor, interceptors)
+
+                call_or_response_iterator = await interceptor.intercept_unary_stream(
+                    continuation, client_call_details, request)
+
+                if isinstance(call_or_response_iterator,
+                              _base_call.UnaryStreamCall):
+                    self._last_returned_call_from_interceptors = call_or_response_iterator
+                else:
+                    self._last_returned_call_from_interceptors = UnaryStreamCallResponseIterator(
+                        self._last_returned_call_from_interceptors,
+                        call_or_response_iterator)
+                return self._last_returned_call_from_interceptors
+            else:
+                self._last_returned_call_from_interceptors = UnaryStreamCall(
+                    request, _timeout_to_deadline(client_call_details.timeout),
+                    client_call_details.metadata,
+                    client_call_details.credentials,
+                    client_call_details.wait_for_ready, self._channel,
+                    client_call_details.method, request_serializer,
+                    response_deserializer, self._loop)
+
+                return self._last_returned_call_from_interceptors
+
+        client_call_details = ClientCallDetails(method, timeout, metadata,
+                                                credentials, wait_for_ready)
+        return await _run_interceptor(iter(interceptors), client_call_details,
+                                      request)
+
+    def time_remaining(self) -> Optional[float]:
+        raise NotImplementedError()
+
+
+class InterceptedStreamUnaryCall(_InterceptedUnaryResponseMixin,
+                                 _InterceptedStreamRequestMixin,
+                                 InterceptedCall, _base_call.StreamUnaryCall):
+    """Used for running a `StreamUnaryCall` wrapped by interceptors.
+
+    For the `__await__` method is it is proxied to the intercepted call only when
+    the interceptor task is finished.
+    """
+
+    _loop: asyncio.AbstractEventLoop
+    _channel: cygrpc.AioChannel
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, interceptors: Sequence[StreamUnaryClientInterceptor],
+                 request_iterator: Optional[RequestIterableType],
+                 timeout: Optional[float], metadata: Metadata,
+                 credentials: Optional[grpc.CallCredentials],
+                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel,
+                 method: bytes, request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._channel = channel
+        request_iterator = self._init_stream_request_mixin(request_iterator)
+        interceptors_task = loop.create_task(
+            self._invoke(interceptors, method, timeout, metadata, credentials,
+                         wait_for_ready, request_iterator, request_serializer,
+                         response_deserializer))
+        super().__init__(interceptors_task)
+
+    # pylint: disable=too-many-arguments
+    async def _invoke(
+            self, interceptors: Sequence[StreamUnaryClientInterceptor],
+            method: bytes, timeout: Optional[float],
+            metadata: Optional[Metadata],
+            credentials: Optional[grpc.CallCredentials],
+            wait_for_ready: Optional[bool],
+            request_iterator: RequestIterableType,
+            request_serializer: SerializingFunction,
+            response_deserializer: DeserializingFunction) -> StreamUnaryCall:
+        """Run the RPC call wrapped in interceptors"""
+
+        async def _run_interceptor(
+                interceptors: Iterator[UnaryUnaryClientInterceptor],
+                client_call_details: ClientCallDetails,
+                request_iterator: RequestIterableType
+        ) -> _base_call.StreamUnaryCall:
+
+            interceptor = next(interceptors, None)
+
+            if interceptor:
+                continuation = functools.partial(_run_interceptor, interceptors)
+
+                return await interceptor.intercept_stream_unary(
+                    continuation, client_call_details, request_iterator)
+            else:
+                return StreamUnaryCall(
+                    request_iterator,
+                    _timeout_to_deadline(client_call_details.timeout),
+                    client_call_details.metadata,
+                    client_call_details.credentials,
+                    client_call_details.wait_for_ready, self._channel,
+                    client_call_details.method, request_serializer,
+                    response_deserializer, self._loop)
+
+        client_call_details = ClientCallDetails(method, timeout, metadata,
+                                                credentials, wait_for_ready)
+        return await _run_interceptor(iter(interceptors), client_call_details,
+                                      request_iterator)
+
+    def time_remaining(self) -> Optional[float]:
+        raise NotImplementedError()
+
+
+class InterceptedStreamStreamCall(_InterceptedStreamResponseMixin,
+                                  _InterceptedStreamRequestMixin,
+                                  InterceptedCall, _base_call.StreamStreamCall):
+    """Used for running a `StreamStreamCall` wrapped by interceptors."""
+
+    _loop: asyncio.AbstractEventLoop
+    _channel: cygrpc.AioChannel
+    _last_returned_call_from_interceptors = Optional[_base_call.UnaryStreamCall]
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, interceptors: Sequence[StreamStreamClientInterceptor],
+                 request_iterator: Optional[RequestIterableType],
+                 timeout: Optional[float], metadata: Metadata,
+                 credentials: Optional[grpc.CallCredentials],
+                 wait_for_ready: Optional[bool], channel: cygrpc.AioChannel,
+                 method: bytes, request_serializer: SerializingFunction,
+                 response_deserializer: DeserializingFunction,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self._channel = channel
+        self._init_stream_response_mixin()
+        request_iterator = self._init_stream_request_mixin(request_iterator)
+        self._last_returned_call_from_interceptors = None
+        interceptors_task = loop.create_task(
+            self._invoke(interceptors, method, timeout, metadata, credentials,
+                         wait_for_ready, request_iterator, request_serializer,
+                         response_deserializer))
+        super().__init__(interceptors_task)
+
+    # pylint: disable=too-many-arguments
+    async def _invoke(
+            self, interceptors: Sequence[StreamStreamClientInterceptor],
+            method: bytes, timeout: Optional[float],
+            metadata: Optional[Metadata],
+            credentials: Optional[grpc.CallCredentials],
+            wait_for_ready: Optional[bool],
+            request_iterator: RequestIterableType,
+            request_serializer: SerializingFunction,
+            response_deserializer: DeserializingFunction) -> StreamStreamCall:
+        """Run the RPC call wrapped in interceptors"""
+
+        async def _run_interceptor(
+                interceptors: Iterator[StreamStreamClientInterceptor],
+                client_call_details: ClientCallDetails,
+                request_iterator: RequestIterableType
+        ) -> _base_call.StreamStreamCall:
+
+            interceptor = next(interceptors, None)
+
+            if interceptor:
+                continuation = functools.partial(_run_interceptor, interceptors)
+
+                call_or_response_iterator = await interceptor.intercept_stream_stream(
+                    continuation, client_call_details, request_iterator)
+
+                if isinstance(call_or_response_iterator,
+                              _base_call.StreamStreamCall):
+                    self._last_returned_call_from_interceptors = call_or_response_iterator
+                else:
+                    self._last_returned_call_from_interceptors = StreamStreamCallResponseIterator(
+                        self._last_returned_call_from_interceptors,
+                        call_or_response_iterator)
+                return self._last_returned_call_from_interceptors
+            else:
+                self._last_returned_call_from_interceptors = StreamStreamCall(
+                    request_iterator,
+                    _timeout_to_deadline(client_call_details.timeout),
+                    client_call_details.metadata,
+                    client_call_details.credentials,
+                    client_call_details.wait_for_ready, self._channel,
+                    client_call_details.method, request_serializer,
+                    response_deserializer, self._loop)
+                return self._last_returned_call_from_interceptors
+
+        client_call_details = ClientCallDetails(method, timeout, metadata,
+                                                credentials, wait_for_ready)
+        return await _run_interceptor(iter(interceptors), client_call_details,
+                                      request_iterator)
+
+    def time_remaining(self) -> Optional[float]:
+        raise NotImplementedError()
+
+
+class UnaryUnaryCallResponse(_base_call.UnaryUnaryCall):
+    """Final UnaryUnaryCall class finished with a response."""
+    _response: ResponseType
+
+    def __init__(self, response: ResponseType) -> None:
+        self._response = response
+
+    def cancel(self) -> bool:
+        return False
+
+    def cancelled(self) -> bool:
+        return False
+
+    def done(self) -> bool:
+        return True
+
+    def add_done_callback(self, unused_callback) -> None:
+        raise NotImplementedError()
+
+    def time_remaining(self) -> Optional[float]:
+        raise NotImplementedError()
+
+    async def initial_metadata(self) -> Optional[Metadata]:
+        return None
+
+    async def trailing_metadata(self) -> Optional[Metadata]:
+        return None
+
+    async def code(self) -> grpc.StatusCode:
+        return grpc.StatusCode.OK
+
+    async def details(self) -> str:
+        return ''
+
+    async def debug_error_string(self) -> Optional[str]:
+        return None
+
+    def __await__(self):
+        if False:  # pylint: disable=using-constant-test
+            # This code path is never used, but a yield statement is needed
+            # for telling the interpreter that __await__ is a generator.
+            yield None
+        return self._response
+
+    async def wait_for_connection(self) -> None:
+        pass
+
+
+class _StreamCallResponseIterator:
+
+    _call: Union[_base_call.UnaryStreamCall, _base_call.StreamStreamCall]
+    _response_iterator: AsyncIterable[ResponseType]
+
+    def __init__(self, call: Union[_base_call.UnaryStreamCall, _base_call.
+                                   StreamStreamCall],
+                 response_iterator: AsyncIterable[ResponseType]) -> None:
+        self._response_iterator = response_iterator
+        self._call = call
+
+    def cancel(self) -> bool:
+        return self._call.cancel()
+
+    def cancelled(self) -> bool:
+        return self._call.cancelled()
+
+    def done(self) -> bool:
+        return self._call.done()
+
+    def add_done_callback(self, callback) -> None:
+        self._call.add_done_callback(callback)
+
+    def time_remaining(self) -> Optional[float]:
+        return self._call.time_remaining()
+
+    async def initial_metadata(self) -> Optional[Metadata]:
+        return await self._call.initial_metadata()
+
+    async def trailing_metadata(self) -> Optional[Metadata]:
+        return await self._call.trailing_metadata()
+
+    async def code(self) -> grpc.StatusCode:
+        return await self._call.code()
+
+    async def details(self) -> str:
+        return await self._call.details()
+
+    async def debug_error_string(self) -> Optional[str]:
+        return await self._call.debug_error_string()
+
+    def __aiter__(self):
+        return self._response_iterator.__aiter__()
+
+    async def wait_for_connection(self) -> None:
+        return await self._call.wait_for_connection()
+
+
+class UnaryStreamCallResponseIterator(_StreamCallResponseIterator,
+                                      _base_call.UnaryStreamCall):
+    """UnaryStreamCall class wich uses an alternative response iterator."""
+
+    async def read(self) -> ResponseType:
+        # Behind the scenes everyting goes through the
+        # async iterator. So this path should not be reached.
+        raise NotImplementedError()
+
+
+class StreamStreamCallResponseIterator(_StreamCallResponseIterator,
+                                       _base_call.StreamStreamCall):
+    """StreamStreamCall class wich uses an alternative response iterator."""
+
+    async def read(self) -> ResponseType:
+        # Behind the scenes everyting goes through the
+        # async iterator. So this path should not be reached.
+        raise NotImplementedError()
+
+    async def write(self, request: RequestType) -> None:
+        # Behind the scenes everyting goes through the
+        # async iterator provided by the InterceptedStreamStreamCall.
+        # So this path should not be reached.
+        raise NotImplementedError()
+
+    async def done_writing(self) -> None:
+        # Behind the scenes everyting goes through the
+        # async iterator provided by the InterceptedStreamStreamCall.
+        # So this path should not be reached.
+        raise NotImplementedError()
+
+    @property
+    def _done_writing_flag(self) -> bool:
+        return self._call._done_writing_flag
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_metadata.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_metadata.py
index a53158831f..3c7d924404 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_metadata.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_metadata.py
@@ -1,119 +1,119 @@
-# Copyright 2020 gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Implementation of the metadata abstraction for gRPC Asyncio Python.""" 
-from typing import List, Tuple, Iterator, Any, Union 
-from collections import abc, OrderedDict 
- 
-MetadataKey = str 
-MetadataValue = Union[str, bytes] 
- 
- 
-class Metadata(abc.Mapping): 
-    """Metadata abstraction for the asynchronous calls and interceptors. 
- 
-    The metadata is a mapping from str -> List[str] 
- 
-    Traits 
-        * Multiple entries are allowed for the same key 
-        * The order of the values by key is preserved 
-        * Getting by an element by key, retrieves the first mapped value 
-        * Supports an immutable view of the data 
-        * Allows partial mutation on the data without recreating the new object from scratch. 
-    """ 
- 
-    def __init__(self, *args: Tuple[MetadataKey, MetadataValue]) -> None: 
-        self._metadata = OrderedDict() 
-        for md_key, md_value in args: 
-            self.add(md_key, md_value) 
- 
-    @classmethod 
-    def from_tuple(cls, raw_metadata: tuple): 
-        if raw_metadata: 
-            return cls(*raw_metadata) 
-        return cls() 
- 
-    def add(self, key: MetadataKey, value: MetadataValue) -> None: 
-        self._metadata.setdefault(key, []) 
-        self._metadata[key].append(value) 
- 
-    def __len__(self) -> int: 
-        """Return the total number of elements that there are in the metadata, 
-        including multiple values for the same key. 
-        """ 
-        return sum(map(len, self._metadata.values())) 
- 
-    def __getitem__(self, key: MetadataKey) -> MetadataValue: 
-        """When calling <metadata>[<key>], the first element of all those 
-        mapped for <key> is returned. 
-        """ 
-        try: 
-            return self._metadata[key][0] 
-        except (ValueError, IndexError) as e: 
-            raise KeyError("{0!r}".format(key)) from e 
- 
-    def __setitem__(self, key: MetadataKey, value: MetadataValue) -> None: 
-        """Calling metadata[<key>] = <value> 
-        Maps <value> to the first instance of <key>. 
-        """ 
-        if key not in self: 
-            self._metadata[key] = [value] 
-        else: 
-            current_values = self.get_all(key) 
-            self._metadata[key] = [value, *current_values[1:]] 
- 
-    def __delitem__(self, key: MetadataKey) -> None: 
-        """``del metadata[<key>]`` deletes the first mapping for <key>.""" 
-        current_values = self.get_all(key) 
-        if not current_values: 
-            raise KeyError(repr(key)) 
-        self._metadata[key] = current_values[1:] 
- 
-    def delete_all(self, key: MetadataKey) -> None: 
-        """Delete all mappings for <key>.""" 
-        del self._metadata[key] 
- 
-    def __iter__(self) -> Iterator[Tuple[MetadataKey, MetadataValue]]: 
-        for key, values in self._metadata.items(): 
-            for value in values: 
-                yield (key, value) 
- 
-    def get_all(self, key: MetadataKey) -> List[MetadataValue]: 
-        """For compatibility with other Metadata abstraction objects (like in Java), 
-        this would return all items under the desired <key>. 
-        """ 
-        return self._metadata.get(key, []) 
- 
-    def set_all(self, key: MetadataKey, values: List[MetadataValue]) -> None: 
-        self._metadata[key] = values 
- 
-    def __contains__(self, key: MetadataKey) -> bool: 
-        return key in self._metadata 
- 
-    def __eq__(self, other: Any) -> bool: 
-        if isinstance(other, self.__class__): 
-            return self._metadata == other._metadata 
-        if isinstance(other, tuple): 
-            return tuple(self) == other 
-        return NotImplemented  # pytype: disable=bad-return-type 
- 
-    def __add__(self, other: Any) -> 'Metadata': 
-        if isinstance(other, self.__class__): 
-            return Metadata(*(tuple(self) + tuple(other))) 
-        if isinstance(other, tuple): 
-            return Metadata(*(tuple(self) + other)) 
-        return NotImplemented  # pytype: disable=bad-return-type 
- 
-    def __repr__(self) -> str: 
-        view = tuple(self) 
-        return "{0}({1!r})".format(self.__class__.__name__, view) 
+# Copyright 2020 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Implementation of the metadata abstraction for gRPC Asyncio Python."""
+from typing import List, Tuple, Iterator, Any, Union
+from collections import abc, OrderedDict
+
+MetadataKey = str
+MetadataValue = Union[str, bytes]
+
+
+class Metadata(abc.Mapping):
+    """Metadata abstraction for the asynchronous calls and interceptors.
+
+    The metadata is a mapping from str -> List[str]
+
+    Traits
+        * Multiple entries are allowed for the same key
+        * The order of the values by key is preserved
+        * Getting by an element by key, retrieves the first mapped value
+        * Supports an immutable view of the data
+        * Allows partial mutation on the data without recreating the new object from scratch.
+    """
+
+    def __init__(self, *args: Tuple[MetadataKey, MetadataValue]) -> None:
+        self._metadata = OrderedDict()
+        for md_key, md_value in args:
+            self.add(md_key, md_value)
+
+    @classmethod
+    def from_tuple(cls, raw_metadata: tuple):
+        if raw_metadata:
+            return cls(*raw_metadata)
+        return cls()
+
+    def add(self, key: MetadataKey, value: MetadataValue) -> None:
+        self._metadata.setdefault(key, [])
+        self._metadata[key].append(value)
+
+    def __len__(self) -> int:
+        """Return the total number of elements that there are in the metadata,
+        including multiple values for the same key.
+        """
+        return sum(map(len, self._metadata.values()))
+
+    def __getitem__(self, key: MetadataKey) -> MetadataValue:
+        """When calling <metadata>[<key>], the first element of all those
+        mapped for <key> is returned.
+        """
+        try:
+            return self._metadata[key][0]
+        except (ValueError, IndexError) as e:
+            raise KeyError("{0!r}".format(key)) from e
+
+    def __setitem__(self, key: MetadataKey, value: MetadataValue) -> None:
+        """Calling metadata[<key>] = <value>
+        Maps <value> to the first instance of <key>.
+        """
+        if key not in self:
+            self._metadata[key] = [value]
+        else:
+            current_values = self.get_all(key)
+            self._metadata[key] = [value, *current_values[1:]]
+
+    def __delitem__(self, key: MetadataKey) -> None:
+        """``del metadata[<key>]`` deletes the first mapping for <key>."""
+        current_values = self.get_all(key)
+        if not current_values:
+            raise KeyError(repr(key))
+        self._metadata[key] = current_values[1:]
+
+    def delete_all(self, key: MetadataKey) -> None:
+        """Delete all mappings for <key>."""
+        del self._metadata[key]
+
+    def __iter__(self) -> Iterator[Tuple[MetadataKey, MetadataValue]]:
+        for key, values in self._metadata.items():
+            for value in values:
+                yield (key, value)
+
+    def get_all(self, key: MetadataKey) -> List[MetadataValue]:
+        """For compatibility with other Metadata abstraction objects (like in Java),
+        this would return all items under the desired <key>.
+        """
+        return self._metadata.get(key, [])
+
+    def set_all(self, key: MetadataKey, values: List[MetadataValue]) -> None:
+        self._metadata[key] = values
+
+    def __contains__(self, key: MetadataKey) -> bool:
+        return key in self._metadata
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, self.__class__):
+            return self._metadata == other._metadata
+        if isinstance(other, tuple):
+            return tuple(self) == other
+        return NotImplemented  # pytype: disable=bad-return-type
+
+    def __add__(self, other: Any) -> 'Metadata':
+        if isinstance(other, self.__class__):
+            return Metadata(*(tuple(self) + tuple(other)))
+        if isinstance(other, tuple):
+            return Metadata(*(tuple(self) + other))
+        return NotImplemented  # pytype: disable=bad-return-type
+
+    def __repr__(self) -> str:
+        view = tuple(self)
+        return "{0}({1!r})".format(self.__class__.__name__, view)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_server.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_server.py
index 023c65dd06..4d7cb75892 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_server.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_server.py
@@ -1,209 +1,209 @@
-# Copyright 2019 The gRPC Authors 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Server-side implementation of gRPC Asyncio Python.""" 
- 
-from concurrent.futures import Executor 
-from typing import Any, Optional, Sequence 
- 
-import grpc 
-from grpc import _common, _compression 
-from grpc._cython import cygrpc 
- 
-from . import _base_server 
-from ._typing import ChannelArgumentType 
-from ._interceptor import ServerInterceptor 
- 
- 
-def _augment_channel_arguments(base_options: ChannelArgumentType, 
-                               compression: Optional[grpc.Compression]): 
-    compression_option = _compression.create_channel_option(compression) 
-    return tuple(base_options) + compression_option 
- 
- 
-class Server(_base_server.Server): 
-    """Serves RPCs.""" 
- 
-    def __init__(self, thread_pool: Optional[Executor], 
-                 generic_handlers: Optional[Sequence[grpc.GenericRpcHandler]], 
-                 interceptors: Optional[Sequence[Any]], 
-                 options: ChannelArgumentType, 
-                 maximum_concurrent_rpcs: Optional[int], 
-                 compression: Optional[grpc.Compression]): 
-        self._loop = cygrpc.get_working_loop() 
-        if interceptors: 
-            invalid_interceptors = [ 
-                interceptor for interceptor in interceptors 
-                if not isinstance(interceptor, ServerInterceptor) 
-            ] 
-            if invalid_interceptors: 
-                raise ValueError( 
-                    'Interceptor must be ServerInterceptor, the ' 
-                    f'following are invalid: {invalid_interceptors}') 
-        self._server = cygrpc.AioServer( 
-            self._loop, thread_pool, generic_handlers, interceptors, 
-            _augment_channel_arguments(options, compression), 
-            maximum_concurrent_rpcs) 
- 
-    def add_generic_rpc_handlers( 
-            self, 
-            generic_rpc_handlers: Sequence[grpc.GenericRpcHandler]) -> None: 
-        """Registers GenericRpcHandlers with this Server. 
- 
-        This method is only safe to call before the server is started. 
- 
-        Args: 
-          generic_rpc_handlers: A sequence of GenericRpcHandlers that will be 
-          used to service RPCs. 
-        """ 
-        self._server.add_generic_rpc_handlers(generic_rpc_handlers) 
- 
-    def add_insecure_port(self, address: str) -> int: 
-        """Opens an insecure port for accepting RPCs. 
- 
-        This method may only be called before starting the server. 
- 
-        Args: 
-          address: The address for which to open a port. If the port is 0, 
-            or not specified in the address, then the gRPC runtime will choose a port. 
- 
-        Returns: 
-          An integer port on which the server will accept RPC requests. 
-        """ 
-        return _common.validate_port_binding_result( 
-            address, self._server.add_insecure_port(_common.encode(address))) 
- 
-    def add_secure_port(self, address: str, 
-                        server_credentials: grpc.ServerCredentials) -> int: 
-        """Opens a secure port for accepting RPCs. 
- 
-        This method may only be called before starting the server. 
- 
-        Args: 
-          address: The address for which to open a port. 
-            if the port is 0, or not specified in the address, then the gRPC 
-            runtime will choose a port. 
-          server_credentials: A ServerCredentials object. 
- 
-        Returns: 
-          An integer port on which the server will accept RPC requests. 
-        """ 
-        return _common.validate_port_binding_result( 
-            address, 
-            self._server.add_secure_port(_common.encode(address), 
-                                         server_credentials)) 
- 
-    async def start(self) -> None: 
-        """Starts this Server. 
- 
-        This method may only be called once. (i.e. it is not idempotent). 
-        """ 
-        await self._server.start() 
- 
-    async def stop(self, grace: Optional[float]) -> None: 
-        """Stops this Server. 
- 
-        This method immediately stops the server from servicing new RPCs in 
-        all cases. 
- 
-        If a grace period is specified, this method returns immediately and all 
-        RPCs active at the end of the grace period are aborted. If a grace 
-        period is not specified (by passing None for grace), all existing RPCs 
-        are aborted immediately and this method blocks until the last RPC 
-        handler terminates. 
- 
-        This method is idempotent and may be called at any time. Passing a 
-        smaller grace value in a subsequent call will have the effect of 
-        stopping the Server sooner (passing None will have the effect of 
-        stopping the server immediately). Passing a larger grace value in a 
-        subsequent call will not have the effect of stopping the server later 
-        (i.e. the most restrictive grace value is used). 
- 
-        Args: 
-          grace: A duration of time in seconds or None. 
-        """ 
-        await self._server.shutdown(grace) 
- 
-    async def wait_for_termination(self, 
-                                   timeout: Optional[float] = None) -> bool: 
-        """Block current coroutine until the server stops. 
- 
-        This is an EXPERIMENTAL API. 
- 
-        The wait will not consume computational resources during blocking, and 
-        it will block until one of the two following conditions are met: 
- 
-        1) The server is stopped or terminated; 
-        2) A timeout occurs if timeout is not `None`. 
- 
-        The timeout argument works in the same way as `threading.Event.wait()`. 
-        https://docs.python.org/3/library/threading.html#threading.Event.wait 
- 
-        Args: 
-          timeout: A floating point number specifying a timeout for the 
-            operation in seconds. 
- 
-        Returns: 
-          A bool indicates if the operation times out. 
-        """ 
-        return await self._server.wait_for_termination(timeout) 
- 
-    def __del__(self): 
-        """Schedules a graceful shutdown in current event loop. 
- 
-        The Cython AioServer doesn't hold a ref-count to this class. It should 
-        be safe to slightly extend the underlying Cython object's life span. 
-        """ 
-        if hasattr(self, '_server'): 
-            if self._server.is_running(): 
-                cygrpc.schedule_coro_threadsafe( 
-                    self._server.shutdown(None), 
-                    self._loop, 
-                ) 
- 
- 
-def server(migration_thread_pool: Optional[Executor] = None, 
-           handlers: Optional[Sequence[grpc.GenericRpcHandler]] = None, 
-           interceptors: Optional[Sequence[Any]] = None, 
-           options: Optional[ChannelArgumentType] = None, 
-           maximum_concurrent_rpcs: Optional[int] = None, 
-           compression: Optional[grpc.Compression] = None): 
-    """Creates a Server with which RPCs can be serviced. 
- 
-    Args: 
-      migration_thread_pool: A futures.ThreadPoolExecutor to be used by the 
-        Server to execute non-AsyncIO RPC handlers for migration purpose. 
-      handlers: An optional list of GenericRpcHandlers used for executing RPCs. 
-        More handlers may be added by calling add_generic_rpc_handlers any time 
-        before the server is started. 
-      interceptors: An optional list of ServerInterceptor objects that observe 
-        and optionally manipulate the incoming RPCs before handing them over to 
-        handlers. The interceptors are given control in the order they are 
-        specified. This is an EXPERIMENTAL API. 
-      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC runtime) 
-        to configure the channel. 
-      maximum_concurrent_rpcs: The maximum number of concurrent RPCs this server 
-        will service before returning RESOURCE_EXHAUSTED status, or None to 
-        indicate no limit. 
-      compression: An element of grpc.compression, e.g. 
-        grpc.compression.Gzip. This compression algorithm will be used for the 
-        lifetime of the server unless overridden by set_compression. This is an 
-        EXPERIMENTAL option. 
- 
-    Returns: 
-      A Server object. 
-    """ 
-    return Server(migration_thread_pool, () if handlers is None else handlers, 
-                  () if interceptors is None else interceptors, 
-                  () if options is None else options, maximum_concurrent_rpcs, 
-                  compression) 
+# Copyright 2019 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Server-side implementation of gRPC Asyncio Python."""
+
+from concurrent.futures import Executor
+from typing import Any, Optional, Sequence
+
+import grpc
+from grpc import _common, _compression
+from grpc._cython import cygrpc
+
+from . import _base_server
+from ._typing import ChannelArgumentType
+from ._interceptor import ServerInterceptor
+
+
+def _augment_channel_arguments(base_options: ChannelArgumentType,
+                               compression: Optional[grpc.Compression]):
+    compression_option = _compression.create_channel_option(compression)
+    return tuple(base_options) + compression_option
+
+
+class Server(_base_server.Server):
+    """Serves RPCs."""
+
+    def __init__(self, thread_pool: Optional[Executor],
+                 generic_handlers: Optional[Sequence[grpc.GenericRpcHandler]],
+                 interceptors: Optional[Sequence[Any]],
+                 options: ChannelArgumentType,
+                 maximum_concurrent_rpcs: Optional[int],
+                 compression: Optional[grpc.Compression]):
+        self._loop = cygrpc.get_working_loop()
+        if interceptors:
+            invalid_interceptors = [
+                interceptor for interceptor in interceptors
+                if not isinstance(interceptor, ServerInterceptor)
+            ]
+            if invalid_interceptors:
+                raise ValueError(
+                    'Interceptor must be ServerInterceptor, the '
+                    f'following are invalid: {invalid_interceptors}')
+        self._server = cygrpc.AioServer(
+            self._loop, thread_pool, generic_handlers, interceptors,
+            _augment_channel_arguments(options, compression),
+            maximum_concurrent_rpcs)
+
+    def add_generic_rpc_handlers(
+            self,
+            generic_rpc_handlers: Sequence[grpc.GenericRpcHandler]) -> None:
+        """Registers GenericRpcHandlers with this Server.
+
+        This method is only safe to call before the server is started.
+
+        Args:
+          generic_rpc_handlers: A sequence of GenericRpcHandlers that will be
+          used to service RPCs.
+        """
+        self._server.add_generic_rpc_handlers(generic_rpc_handlers)
+
+    def add_insecure_port(self, address: str) -> int:
+        """Opens an insecure port for accepting RPCs.
+
+        This method may only be called before starting the server.
+
+        Args:
+          address: The address for which to open a port. If the port is 0,
+            or not specified in the address, then the gRPC runtime will choose a port.
+
+        Returns:
+          An integer port on which the server will accept RPC requests.
+        """
+        return _common.validate_port_binding_result(
+            address, self._server.add_insecure_port(_common.encode(address)))
+
+    def add_secure_port(self, address: str,
+                        server_credentials: grpc.ServerCredentials) -> int:
+        """Opens a secure port for accepting RPCs.
+
+        This method may only be called before starting the server.
+
+        Args:
+          address: The address for which to open a port.
+            if the port is 0, or not specified in the address, then the gRPC
+            runtime will choose a port.
+          server_credentials: A ServerCredentials object.
+
+        Returns:
+          An integer port on which the server will accept RPC requests.
+        """
+        return _common.validate_port_binding_result(
+            address,
+            self._server.add_secure_port(_common.encode(address),
+                                         server_credentials))
+
+    async def start(self) -> None:
+        """Starts this Server.
+
+        This method may only be called once. (i.e. it is not idempotent).
+        """
+        await self._server.start()
+
+    async def stop(self, grace: Optional[float]) -> None:
+        """Stops this Server.
+
+        This method immediately stops the server from servicing new RPCs in
+        all cases.
+
+        If a grace period is specified, this method returns immediately and all
+        RPCs active at the end of the grace period are aborted. If a grace
+        period is not specified (by passing None for grace), all existing RPCs
+        are aborted immediately and this method blocks until the last RPC
+        handler terminates.
+
+        This method is idempotent and may be called at any time. Passing a
+        smaller grace value in a subsequent call will have the effect of
+        stopping the Server sooner (passing None will have the effect of
+        stopping the server immediately). Passing a larger grace value in a
+        subsequent call will not have the effect of stopping the server later
+        (i.e. the most restrictive grace value is used).
+
+        Args:
+          grace: A duration of time in seconds or None.
+        """
+        await self._server.shutdown(grace)
+
+    async def wait_for_termination(self,
+                                   timeout: Optional[float] = None) -> bool:
+        """Block current coroutine until the server stops.
+
+        This is an EXPERIMENTAL API.
+
+        The wait will not consume computational resources during blocking, and
+        it will block until one of the two following conditions are met:
+
+        1) The server is stopped or terminated;
+        2) A timeout occurs if timeout is not `None`.
+
+        The timeout argument works in the same way as `threading.Event.wait()`.
+        https://docs.python.org/3/library/threading.html#threading.Event.wait
+
+        Args:
+          timeout: A floating point number specifying a timeout for the
+            operation in seconds.
+
+        Returns:
+          A bool indicates if the operation times out.
+        """
+        return await self._server.wait_for_termination(timeout)
+
+    def __del__(self):
+        """Schedules a graceful shutdown in current event loop.
+
+        The Cython AioServer doesn't hold a ref-count to this class. It should
+        be safe to slightly extend the underlying Cython object's life span.
+        """
+        if hasattr(self, '_server'):
+            if self._server.is_running():
+                cygrpc.schedule_coro_threadsafe(
+                    self._server.shutdown(None),
+                    self._loop,
+                )
+
+
+def server(migration_thread_pool: Optional[Executor] = None,
+           handlers: Optional[Sequence[grpc.GenericRpcHandler]] = None,
+           interceptors: Optional[Sequence[Any]] = None,
+           options: Optional[ChannelArgumentType] = None,
+           maximum_concurrent_rpcs: Optional[int] = None,
+           compression: Optional[grpc.Compression] = None):
+    """Creates a Server with which RPCs can be serviced.
+
+    Args:
+      migration_thread_pool: A futures.ThreadPoolExecutor to be used by the
+        Server to execute non-AsyncIO RPC handlers for migration purpose.
+      handlers: An optional list of GenericRpcHandlers used for executing RPCs.
+        More handlers may be added by calling add_generic_rpc_handlers any time
+        before the server is started.
+      interceptors: An optional list of ServerInterceptor objects that observe
+        and optionally manipulate the incoming RPCs before handing them over to
+        handlers. The interceptors are given control in the order they are
+        specified. This is an EXPERIMENTAL API.
+      options: An optional list of key-value pairs (:term:`channel_arguments` in gRPC runtime)
+        to configure the channel.
+      maximum_concurrent_rpcs: The maximum number of concurrent RPCs this server
+        will service before returning RESOURCE_EXHAUSTED status, or None to
+        indicate no limit.
+      compression: An element of grpc.compression, e.g.
+        grpc.compression.Gzip. This compression algorithm will be used for the
+        lifetime of the server unless overridden by set_compression. This is an
+        EXPERIMENTAL option.
+
+    Returns:
+      A Server object.
+    """
+    return Server(migration_thread_pool, () if handlers is None else handlers,
+                  () if interceptors is None else interceptors,
+                  () if options is None else options, maximum_concurrent_rpcs,
+                  compression)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_typing.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_typing.py
index e0205bd63c..7e2e8da8a0 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_typing.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_typing.py
@@ -1,32 +1,32 @@
-# Copyright 2019 The gRPC Authors 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Common types for gRPC Async API""" 
- 
-from typing import (Any, AsyncIterable, Callable, Iterable, Sequence, Tuple, 
-                    TypeVar, Union) 
- 
-from grpc._cython.cygrpc import EOF 
-from ._metadata import Metadata, MetadataKey, MetadataValue 
- 
-RequestType = TypeVar('RequestType') 
-ResponseType = TypeVar('ResponseType') 
-SerializingFunction = Callable[[Any], bytes] 
-DeserializingFunction = Callable[[bytes], Any] 
-MetadatumType = Tuple[MetadataKey, MetadataValue] 
-MetadataType = Metadata 
-ChannelArgumentType = Sequence[Tuple[str, Any]] 
-EOFType = type(EOF) 
-DoneCallbackType = Callable[[Any], None] 
-RequestIterableType = Union[Iterable[Any], AsyncIterable[Any]] 
-ResponseIterableType = AsyncIterable[Any] 
+# Copyright 2019 The gRPC Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Common types for gRPC Async API"""
+
+from typing import (Any, AsyncIterable, Callable, Iterable, Sequence, Tuple,
+                    TypeVar, Union)
+
+from grpc._cython.cygrpc import EOF
+from ._metadata import Metadata, MetadataKey, MetadataValue
+
+RequestType = TypeVar('RequestType')
+ResponseType = TypeVar('ResponseType')
+SerializingFunction = Callable[[Any], bytes]
+DeserializingFunction = Callable[[bytes], Any]
+MetadatumType = Tuple[MetadataKey, MetadataValue]
+MetadataType = Metadata
+ChannelArgumentType = Sequence[Tuple[str, Any]]
+EOFType = type(EOF)
+DoneCallbackType = Callable[[Any], None]
+RequestIterableType = Union[Iterable[Any], AsyncIterable[Any]]
+ResponseIterableType = AsyncIterable[Any]
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_utils.py b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_utils.py
index e88db8ad4f..e5772dce2d 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/aio/_utils.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/aio/_utils.py
@@ -1,22 +1,22 @@
-# Copyright 2019 gRPC authors. 
-# 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at 
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0 
-# 
-# Unless required by applicable law or agreed to in writing, software 
-# distributed under the License is distributed on an "AS IS" BASIS, 
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and 
-# limitations under the License. 
-"""Internal utilities used by the gRPC Aio module.""" 
-import time 
-from typing import Optional 
- 
- 
-def _timeout_to_deadline(timeout: Optional[float]) -> Optional[float]: 
-    if timeout is None: 
-        return None 
-    return time.time() + timeout 
+# Copyright 2019 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Internal utilities used by the gRPC Aio module."""
+import time
+from typing import Optional
+
+
+def _timeout_to_deadline(timeout: Optional[float]) -> Optional[float]:
+    if timeout is None:
+        return None
+    return time.time() + timeout
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/beta/_client_adaptations.py b/contrib/libs/grpc/src/python/grpcio/grpc/beta/_client_adaptations.py
index bd5d66e426..652ae0ea17 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/beta/_client_adaptations.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/beta/_client_adaptations.py
@@ -24,14 +24,14 @@ from grpc.framework.interfaces.face import face
 # pylint: disable=too-many-arguments,too-many-locals,unused-argument
 
 _STATUS_CODE_TO_ABORTION_KIND_AND_ABORTION_ERROR_CLASS = {
-    grpc.StatusCode.CANCELLED: 
-        (face.Abortion.Kind.CANCELLED, face.CancellationError), 
-    grpc.StatusCode.UNKNOWN: 
-        (face.Abortion.Kind.REMOTE_FAILURE, face.RemoteError), 
-    grpc.StatusCode.DEADLINE_EXCEEDED: 
-        (face.Abortion.Kind.EXPIRED, face.ExpirationError), 
-    grpc.StatusCode.UNIMPLEMENTED: 
-        (face.Abortion.Kind.LOCAL_FAILURE, face.LocalError), 
+    grpc.StatusCode.CANCELLED:
+        (face.Abortion.Kind.CANCELLED, face.CancellationError),
+    grpc.StatusCode.UNKNOWN:
+        (face.Abortion.Kind.REMOTE_FAILURE, face.RemoteError),
+    grpc.StatusCode.DEADLINE_EXCEEDED:
+        (face.Abortion.Kind.EXPIRED, face.ExpirationError),
+    grpc.StatusCode.UNIMPLEMENTED:
+        (face.Abortion.Kind.LOCAL_FAILURE, face.LocalError),
 }
 
 
@@ -186,10 +186,10 @@ def _blocking_unary_unary(channel, group, method, timeout, with_call,
                 credentials=_credentials(protocol_options))
             return response, _Rendezvous(None, None, call)
         else:
-            return multi_callable(request, 
-                                  timeout=timeout, 
-                                  metadata=_metadata.unbeta(effective_metadata), 
-                                  credentials=_credentials(protocol_options)) 
+            return multi_callable(request,
+                                  timeout=timeout,
+                                  metadata=_metadata.unbeta(effective_metadata),
+                                  credentials=_credentials(protocol_options))
     except grpc.RpcError as rpc_error_call:
         raise _abortion_error(rpc_error_call)
 
@@ -244,10 +244,10 @@ def _blocking_stream_unary(channel, group, method, timeout, with_call,
                 credentials=_credentials(protocol_options))
             return response, _Rendezvous(None, None, call)
         else:
-            return multi_callable(request_iterator, 
-                                  timeout=timeout, 
-                                  metadata=_metadata.unbeta(effective_metadata), 
-                                  credentials=_credentials(protocol_options)) 
+            return multi_callable(request_iterator,
+                                  timeout=timeout,
+                                  metadata=_metadata.unbeta(effective_metadata),
+                                  credentials=_credentials(protocol_options))
     except grpc.RpcError as rpc_error_call:
         raise _abortion_error(rpc_error_call)
 
@@ -301,18 +301,18 @@ class _UnaryUnaryMultiCallable(face.UnaryUnaryMultiCallable):
                  metadata=None,
                  with_call=False,
                  protocol_options=None):
-        return _blocking_unary_unary(self._channel, self._group, self._method, 
-                                     timeout, with_call, protocol_options, 
-                                     metadata, self._metadata_transformer, 
-                                     request, self._request_serializer, 
-                                     self._response_deserializer) 
+        return _blocking_unary_unary(self._channel, self._group, self._method,
+                                     timeout, with_call, protocol_options,
+                                     metadata, self._metadata_transformer,
+                                     request, self._request_serializer,
+                                     self._response_deserializer)
 
     def future(self, request, timeout, metadata=None, protocol_options=None):
-        return _future_unary_unary(self._channel, self._group, self._method, 
-                                   timeout, protocol_options, metadata, 
-                                   self._metadata_transformer, request, 
-                                   self._request_serializer, 
-                                   self._response_deserializer) 
+        return _future_unary_unary(self._channel, self._group, self._method,
+                                   timeout, protocol_options, metadata,
+                                   self._metadata_transformer, request,
+                                   self._request_serializer,
+                                   self._response_deserializer)
 
     def event(self,
               request,
@@ -336,11 +336,11 @@ class _UnaryStreamMultiCallable(face.UnaryStreamMultiCallable):
         self._response_deserializer = response_deserializer
 
     def __call__(self, request, timeout, metadata=None, protocol_options=None):
-        return _unary_stream(self._channel, self._group, self._method, timeout, 
-                             protocol_options, metadata, 
-                             self._metadata_transformer, request, 
-                             self._request_serializer, 
-                             self._response_deserializer) 
+        return _unary_stream(self._channel, self._group, self._method, timeout,
+                             protocol_options, metadata,
+                             self._metadata_transformer, request,
+                             self._request_serializer,
+                             self._response_deserializer)
 
     def event(self,
               request,
@@ -369,23 +369,23 @@ class _StreamUnaryMultiCallable(face.StreamUnaryMultiCallable):
                  metadata=None,
                  with_call=False,
                  protocol_options=None):
-        return _blocking_stream_unary(self._channel, self._group, self._method, 
-                                      timeout, with_call, protocol_options, 
-                                      metadata, self._metadata_transformer, 
-                                      request_iterator, 
-                                      self._request_serializer, 
-                                      self._response_deserializer) 
+        return _blocking_stream_unary(self._channel, self._group, self._method,
+                                      timeout, with_call, protocol_options,
+                                      metadata, self._metadata_transformer,
+                                      request_iterator,
+                                      self._request_serializer,
+                                      self._response_deserializer)
 
     def future(self,
                request_iterator,
                timeout,
                metadata=None,
                protocol_options=None):
-        return _future_stream_unary(self._channel, self._group, self._method, 
-                                    timeout, protocol_options, metadata, 
-                                    self._metadata_transformer, 
-                                    request_iterator, self._request_serializer, 
-                                    self._response_deserializer) 
+        return _future_stream_unary(self._channel, self._group, self._method,
+                                    timeout, protocol_options, metadata,
+                                    self._metadata_transformer,
+                                    request_iterator, self._request_serializer,
+                                    self._response_deserializer)
 
     def event(self,
               receiver,
@@ -412,11 +412,11 @@ class _StreamStreamMultiCallable(face.StreamStreamMultiCallable):
                  timeout,
                  metadata=None,
                  protocol_options=None):
-        return _stream_stream(self._channel, self._group, self._method, timeout, 
-                              protocol_options, metadata, 
-                              self._metadata_transformer, request_iterator, 
-                              self._request_serializer, 
-                              self._response_deserializer) 
+        return _stream_stream(self._channel, self._group, self._method, timeout,
+                              protocol_options, metadata,
+                              self._metadata_transformer, request_iterator,
+                              self._request_serializer,
+                              self._response_deserializer)
 
     def event(self,
               receiver,
@@ -513,11 +513,11 @@ class _GenericStub(face.GenericStub):
             group,
             method,
         ))
-        return _blocking_stream_unary(self._channel, group, method, timeout, 
-                                      with_call, protocol_options, metadata, 
-                                      self._metadata_transformer, 
-                                      request_iterator, request_serializer, 
-                                      response_deserializer) 
+        return _blocking_stream_unary(self._channel, group, method, timeout,
+                                      with_call, protocol_options, metadata,
+                                      self._metadata_transformer,
+                                      request_iterator, request_serializer,
+                                      response_deserializer)
 
     def future_stream_unary(self,
                             group,
@@ -534,11 +534,11 @@ class _GenericStub(face.GenericStub):
             group,
             method,
         ))
-        return _future_stream_unary(self._channel, group, method, timeout, 
-                                    protocol_options, metadata, 
-                                    self._metadata_transformer, 
-                                    request_iterator, request_serializer, 
-                                    response_deserializer) 
+        return _future_stream_unary(self._channel, group, method, timeout,
+                                    protocol_options, metadata,
+                                    self._metadata_transformer,
+                                    request_iterator, request_serializer,
+                                    response_deserializer)
 
     def inline_stream_stream(self,
                              group,
@@ -611,10 +611,10 @@ class _GenericStub(face.GenericStub):
             group,
             method,
         ))
-        return _UnaryUnaryMultiCallable(self._channel, group, method, 
-                                        self._metadata_transformer, 
-                                        request_serializer, 
-                                        response_deserializer) 
+        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((
@@ -625,10 +625,10 @@ class _GenericStub(face.GenericStub):
             group,
             method,
         ))
-        return _UnaryStreamMultiCallable(self._channel, group, method, 
-                                         self._metadata_transformer, 
-                                         request_serializer, 
-                                         response_deserializer) 
+        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((
@@ -639,10 +639,10 @@ class _GenericStub(face.GenericStub):
             group,
             method,
         ))
-        return _StreamUnaryMultiCallable(self._channel, group, method, 
-                                         self._metadata_transformer, 
-                                         request_serializer, 
-                                         response_deserializer) 
+        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((
@@ -653,10 +653,10 @@ class _GenericStub(face.GenericStub):
             group,
             method,
         ))
-        return _StreamStreamMultiCallable(self._channel, group, method, 
-                                          self._metadata_transformer, 
-                                          request_serializer, 
-                                          response_deserializer) 
+        return _StreamStreamMultiCallable(self._channel, group, method,
+                                          self._metadata_transformer,
+                                          request_serializer,
+                                          response_deserializer)
 
     def __enter__(self):
         return self
@@ -683,8 +683,8 @@ class _DynamicStub(face.DynamicStub):
         elif method_cardinality is cardinality.Cardinality.STREAM_STREAM:
             return self._generic_stub.stream_stream(self._group, attr)
         else:
-            raise AttributeError('_DynamicStub object has no attribute "%s"!' % 
-                                 attr) 
+            raise AttributeError('_DynamicStub object has no attribute "%s"!' %
+                                 attr)
 
     def __enter__(self):
         return self
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/beta/_server_adaptations.py b/contrib/libs/grpc/src/python/grpcio/grpc/beta/_server_adaptations.py
index 678e514a24..8843a3c550 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/beta/_server_adaptations.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/beta/_server_adaptations.py
@@ -258,21 +258,21 @@ def _simple_method_handler(implementation, request_deserializer,
                            response_serializer):
     if implementation.style is style.Service.INLINE:
         if implementation.cardinality is cardinality.Cardinality.UNARY_UNARY:
-            return _SimpleMethodHandler( 
-                False, False, request_deserializer, response_serializer, 
-                _adapt_unary_request_inline(implementation.unary_unary_inline), 
-                None, None, None) 
+            return _SimpleMethodHandler(
+                False, False, request_deserializer, response_serializer,
+                _adapt_unary_request_inline(implementation.unary_unary_inline),
+                None, None, None)
         elif implementation.cardinality is cardinality.Cardinality.UNARY_STREAM:
-            return _SimpleMethodHandler( 
-                False, True, request_deserializer, response_serializer, None, 
-                _adapt_unary_request_inline(implementation.unary_stream_inline), 
-                None, None) 
+            return _SimpleMethodHandler(
+                False, True, request_deserializer, response_serializer, None,
+                _adapt_unary_request_inline(implementation.unary_stream_inline),
+                None, None)
         elif implementation.cardinality is cardinality.Cardinality.STREAM_UNARY:
-            return _SimpleMethodHandler( 
-                True, False, request_deserializer, response_serializer, None, 
-                None, 
-                _adapt_stream_request_inline( 
-                    implementation.stream_unary_inline), None) 
+            return _SimpleMethodHandler(
+                True, False, request_deserializer, response_serializer, None,
+                None,
+                _adapt_stream_request_inline(
+                    implementation.stream_unary_inline), None)
         elif implementation.cardinality is cardinality.Cardinality.STREAM_STREAM:
             return _SimpleMethodHandler(
                 True, True, request_deserializer, response_serializer, None,
@@ -281,26 +281,26 @@ def _simple_method_handler(implementation, request_deserializer,
                     implementation.stream_stream_inline))
     elif implementation.style is style.Service.EVENT:
         if implementation.cardinality is cardinality.Cardinality.UNARY_UNARY:
-            return _SimpleMethodHandler( 
-                False, False, request_deserializer, response_serializer, 
-                _adapt_unary_unary_event(implementation.unary_unary_event), 
-                None, None, None) 
+            return _SimpleMethodHandler(
+                False, False, request_deserializer, response_serializer,
+                _adapt_unary_unary_event(implementation.unary_unary_event),
+                None, None, None)
         elif implementation.cardinality is cardinality.Cardinality.UNARY_STREAM:
-            return _SimpleMethodHandler( 
-                False, True, request_deserializer, response_serializer, None, 
-                _adapt_unary_stream_event(implementation.unary_stream_event), 
-                None, None) 
+            return _SimpleMethodHandler(
+                False, True, request_deserializer, response_serializer, None,
+                _adapt_unary_stream_event(implementation.unary_stream_event),
+                None, None)
         elif implementation.cardinality is cardinality.Cardinality.STREAM_UNARY:
-            return _SimpleMethodHandler( 
-                True, False, request_deserializer, response_serializer, None, 
-                None, 
-                _adapt_stream_unary_event(implementation.stream_unary_event), 
-                None) 
+            return _SimpleMethodHandler(
+                True, False, request_deserializer, response_serializer, None,
+                None,
+                _adapt_stream_unary_event(implementation.stream_unary_event),
+                None)
         elif implementation.cardinality is cardinality.Cardinality.STREAM_STREAM:
-            return _SimpleMethodHandler( 
-                True, True, request_deserializer, response_serializer, None, 
-                None, None, 
-                _adapt_stream_stream_event(implementation.stream_stream_event)) 
+            return _SimpleMethodHandler(
+                True, True, request_deserializer, response_serializer, None,
+                None, None,
+                _adapt_stream_stream_event(implementation.stream_stream_event))
     raise ValueError()
 
 
@@ -329,10 +329,10 @@ class _GenericRpcHandler(grpc.GenericRpcHandler):
         method_implementation = self._method_implementations.get(
             handler_call_details.method)
         if method_implementation is not None:
-            return _simple_method_handler( 
-                method_implementation, 
-                self._request_deserializers.get(handler_call_details.method), 
-                self._response_serializers.get(handler_call_details.method)) 
+            return _simple_method_handler(
+                method_implementation,
+                self._request_deserializers.get(handler_call_details.method),
+                self._response_serializers.get(handler_call_details.method))
         elif self._multi_method_implementation is None:
             return None
         else:
@@ -371,14 +371,14 @@ class _Server(interfaces.Server):
 def server(service_implementations, multi_method_implementation,
            request_deserializers, response_serializers, thread_pool,
            thread_pool_size):
-    generic_rpc_handler = _GenericRpcHandler(service_implementations, 
-                                             multi_method_implementation, 
-                                             request_deserializers, 
-                                             response_serializers) 
+    generic_rpc_handler = _GenericRpcHandler(service_implementations,
+                                             multi_method_implementation,
+                                             request_deserializers,
+                                             response_serializers)
     if thread_pool is None:
-        effective_thread_pool = logging_pool.pool( 
-            _DEFAULT_POOL_SIZE if thread_pool_size is None else thread_pool_size 
-        ) 
+        effective_thread_pool = logging_pool.pool(
+            _DEFAULT_POOL_SIZE if thread_pool_size is None else thread_pool_size
+        )
     else:
         effective_thread_pool = thread_pool
     return _Server(
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/beta/implementations.py b/contrib/libs/grpc/src/python/grpcio/grpc/beta/implementations.py
index 66cd9c90c0..c5507b543f 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/beta/implementations.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/beta/implementations.py
@@ -110,8 +110,8 @@ def insecure_channel(host, port):
   Returns:
     A Channel to the remote host through which RPCs may be conducted.
   """
-    channel = grpc.insecure_channel(host if port is None else '%s:%d' % 
-                                    (host, port)) 
+    channel = grpc.insecure_channel(host if port is None else '%s:%d' %
+                                    (host, port))
     return Channel(channel)
 
 
@@ -127,8 +127,8 @@ def secure_channel(host, port, channel_credentials):
   Returns:
     A secure Channel to the remote host through which RPCs may be conducted.
   """
-    channel = grpc.secure_channel( 
-        host if port is None else '%s:%d' % (host, port), channel_credentials) 
+    channel = grpc.secure_channel(
+        host if port is None else '%s:%d' % (host, port), channel_credentials)
     return Channel(channel)
 
 
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/experimental/__init__.py b/contrib/libs/grpc/src/python/grpcio/grpc/experimental/__init__.py
index 584a7f80e2..a4e2660fb4 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/experimental/__init__.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/experimental/__init__.py
@@ -16,16 +16,16 @@
 These APIs are subject to be removed during any minor version release.
 """
 
-import copy 
-import functools 
-import sys 
-import warnings 
-
-import grpc 
- 
-_EXPERIMENTAL_APIS_USED = set() 
- 
- 
+import copy
+import functools
+import sys
+import warnings
+
+import grpc
+
+_EXPERIMENTAL_APIS_USED = set()
+
+
 class ChannelOptions(object):
     """Indicates a channel option unique to gRPC Python.
 
@@ -39,89 +39,89 @@ class ChannelOptions(object):
 
 class UsageError(Exception):
     """Raised by the gRPC library to indicate usage not allowed by the API."""
- 
- 
-_insecure_channel_credentials_sentinel = object() 
-_insecure_channel_credentials = grpc.ChannelCredentials( 
-    _insecure_channel_credentials_sentinel) 
- 
- 
-def insecure_channel_credentials(): 
-    """Creates a ChannelCredentials for use with an insecure channel. 
- 
-    THIS IS AN EXPERIMENTAL API. 
- 
-    This is not for use with secure_channel function. Intead, this should be 
-    used with grpc.unary_unary, grpc.unary_stream, grpc.stream_unary, or 
-    grpc.stream_stream. 
-    """ 
-    return _insecure_channel_credentials 
- 
- 
-class ExperimentalApiWarning(Warning): 
-    """A warning that an API is experimental.""" 
- 
- 
-def _warn_experimental(api_name, stack_offset): 
-    if api_name not in _EXPERIMENTAL_APIS_USED: 
-        _EXPERIMENTAL_APIS_USED.add(api_name) 
-        msg = ("'{}' is an experimental API. It is subject to change or ". 
-               format(api_name) + 
-               "removal between minor releases. Proceed with caution.") 
-        warnings.warn(msg, ExperimentalApiWarning, stacklevel=2 + stack_offset) 
- 
- 
-def experimental_api(f): 
- 
-    @functools.wraps(f) 
-    def _wrapper(*args, **kwargs): 
-        _warn_experimental(f.__name__, 1) 
-        return f(*args, **kwargs) 
- 
-    return _wrapper 
- 
- 
-def wrap_server_method_handler(wrapper, handler): 
-    """Wraps the server method handler function. 
- 
-    The server implementation requires all server handlers being wrapped as 
-    RpcMethodHandler objects. This helper function ease the pain of writing 
-    server handler wrappers. 
- 
-    Args: 
-        wrapper: A wrapper function that takes in a method handler behavior 
-          (the actual function) and returns a wrapped function. 
-        handler: A RpcMethodHandler object to be wrapped. 
- 
-    Returns: 
-        A newly created RpcMethodHandler. 
-    """ 
-    if not handler: 
-        return None 
- 
-    if not handler.request_streaming: 
-        if not handler.response_streaming: 
-            # NOTE(lidiz) _replace is a public API: 
-            #   https://docs.python.org/dev/library/collections.html 
-            return handler._replace(unary_unary=wrapper(handler.unary_unary)) 
-        else: 
-            return handler._replace(unary_stream=wrapper(handler.unary_stream)) 
-    else: 
-        if not handler.response_streaming: 
-            return handler._replace(stream_unary=wrapper(handler.stream_unary)) 
-        else: 
-            return handler._replace( 
-                stream_stream=wrapper(handler.stream_stream)) 
- 
- 
-__all__ = ( 
-    'ChannelOptions', 
-    'ExperimentalApiWarning', 
-    'UsageError', 
-    'insecure_channel_credentials', 
-    'wrap_server_method_handler', 
-) 
- 
-if sys.version_info > (3, 6): 
-    from grpc._simple_stubs import unary_unary, unary_stream, stream_unary, stream_stream 
-    __all__ = __all__ + (unary_unary, unary_stream, stream_unary, stream_stream) 
+
+
+_insecure_channel_credentials_sentinel = object()
+_insecure_channel_credentials = grpc.ChannelCredentials(
+    _insecure_channel_credentials_sentinel)
+
+
+def insecure_channel_credentials():
+    """Creates a ChannelCredentials for use with an insecure channel.
+
+    THIS IS AN EXPERIMENTAL API.
+
+    This is not for use with secure_channel function. Intead, this should be
+    used with grpc.unary_unary, grpc.unary_stream, grpc.stream_unary, or
+    grpc.stream_stream.
+    """
+    return _insecure_channel_credentials
+
+
+class ExperimentalApiWarning(Warning):
+    """A warning that an API is experimental."""
+
+
+def _warn_experimental(api_name, stack_offset):
+    if api_name not in _EXPERIMENTAL_APIS_USED:
+        _EXPERIMENTAL_APIS_USED.add(api_name)
+        msg = ("'{}' is an experimental API. It is subject to change or ".
+               format(api_name) +
+               "removal between minor releases. Proceed with caution.")
+        warnings.warn(msg, ExperimentalApiWarning, stacklevel=2 + stack_offset)
+
+
+def experimental_api(f):
+
+    @functools.wraps(f)
+    def _wrapper(*args, **kwargs):
+        _warn_experimental(f.__name__, 1)
+        return f(*args, **kwargs)
+
+    return _wrapper
+
+
+def wrap_server_method_handler(wrapper, handler):
+    """Wraps the server method handler function.
+
+    The server implementation requires all server handlers being wrapped as
+    RpcMethodHandler objects. This helper function ease the pain of writing
+    server handler wrappers.
+
+    Args:
+        wrapper: A wrapper function that takes in a method handler behavior
+          (the actual function) and returns a wrapped function.
+        handler: A RpcMethodHandler object to be wrapped.
+
+    Returns:
+        A newly created RpcMethodHandler.
+    """
+    if not handler:
+        return None
+
+    if not handler.request_streaming:
+        if not handler.response_streaming:
+            # NOTE(lidiz) _replace is a public API:
+            #   https://docs.python.org/dev/library/collections.html
+            return handler._replace(unary_unary=wrapper(handler.unary_unary))
+        else:
+            return handler._replace(unary_stream=wrapper(handler.unary_stream))
+    else:
+        if not handler.response_streaming:
+            return handler._replace(stream_unary=wrapper(handler.stream_unary))
+        else:
+            return handler._replace(
+                stream_stream=wrapper(handler.stream_stream))
+
+
+__all__ = (
+    'ChannelOptions',
+    'ExperimentalApiWarning',
+    'UsageError',
+    'insecure_channel_credentials',
+    'wrap_server_method_handler',
+)
+
+if sys.version_info > (3, 6):
+    from grpc._simple_stubs import unary_unary, unary_stream, stream_unary, stream_stream
+    __all__ = __all__ + (unary_unary, unary_stream, stream_unary, stream_stream)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/experimental/aio/__init__.py b/contrib/libs/grpc/src/python/grpcio/grpc/experimental/aio/__init__.py
index c177b4bd53..576cb8dcde 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/experimental/aio/__init__.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/experimental/aio/__init__.py
@@ -1,4 +1,4 @@
-# Copyright 2020 The gRPC Authors 
+# Copyright 2020 The gRPC Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,6 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""Alias of grpc.aio to keep backward compatibility.""" 
+"""Alias of grpc.aio to keep backward compatibility."""
 
-from grpc.aio import * 
+from grpc.aio import *
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc/framework/foundation/logging_pool.py b/contrib/libs/grpc/src/python/grpcio/grpc/framework/foundation/logging_pool.py
index 9119e414a5..421999fb1c 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc/framework/foundation/logging_pool.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc/framework/foundation/logging_pool.py
@@ -51,9 +51,9 @@ class _LoggingPool(object):
         return self._backing_pool.submit(_wrap(fn), *args, **kwargs)
 
     def map(self, func, *iterables, **kwargs):
-        return self._backing_pool.map(_wrap(func), 
-                                      *iterables, 
-                                      timeout=kwargs.get('timeout', None)) 
+        return self._backing_pool.map(_wrap(func),
+                                      *iterables,
+                                      timeout=kwargs.get('timeout', None))
 
     def shutdown(self, wait=True):
         self._backing_pool.shutdown(wait=wait)
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc_core_dependencies.py b/contrib/libs/grpc/src/python/grpcio/grpc_core_dependencies.py
index 2e34549b7d..67f985e1f4 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc_core_dependencies.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc_core_dependencies.py
@@ -23,28 +23,28 @@ CORE_SOURCE_FILES = [
     'src/core/ext/filters/client_channel/client_channel_channelz.cc',
     'src/core/ext/filters/client_channel/client_channel_factory.cc',
     'src/core/ext/filters/client_channel/client_channel_plugin.cc',
-    'src/core/ext/filters/client_channel/config_selector.cc', 
+    'src/core/ext/filters/client_channel/config_selector.cc',
     'src/core/ext/filters/client_channel/global_subchannel_pool.cc',
     'src/core/ext/filters/client_channel/health/health_check_client.cc',
     'src/core/ext/filters/client_channel/http_connect_handshaker.cc',
     'src/core/ext/filters/client_channel/http_proxy.cc',
     'src/core/ext/filters/client_channel/lb_policy.cc',
-    'src/core/ext/filters/client_channel/lb_policy/address_filtering.cc', 
-    'src/core/ext/filters/client_channel/lb_policy/child_policy_handler.cc', 
+    'src/core/ext/filters/client_channel/lb_policy/address_filtering.cc',
+    'src/core/ext/filters/client_channel/lb_policy/child_policy_handler.cc',
     'src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc',
     'src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc',
-    'src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.cc', 
+    'src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.cc',
     'src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_channel_secure.cc',
     'src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.cc',
     'src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.cc',
     'src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.cc',
-    'src/core/ext/filters/client_channel/lb_policy/priority/priority.cc', 
+    'src/core/ext/filters/client_channel/lb_policy/priority/priority.cc',
     'src/core/ext/filters/client_channel/lb_policy/round_robin/round_robin.cc',
-    'src/core/ext/filters/client_channel/lb_policy/weighted_target/weighted_target.cc', 
+    'src/core/ext/filters/client_channel/lb_policy/weighted_target/weighted_target.cc',
     'src/core/ext/filters/client_channel/lb_policy/xds/cds.cc',
-    'src/core/ext/filters/client_channel/lb_policy/xds/eds.cc', 
-    'src/core/ext/filters/client_channel/lb_policy/xds/eds_drop.cc', 
-    'src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_manager.cc', 
+    'src/core/ext/filters/client_channel/lb_policy/xds/eds.cc',
+    'src/core/ext/filters/client_channel/lb_policy/xds/eds_drop.cc',
+    'src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_manager.cc',
     'src/core/ext/filters/client_channel/lb_policy_registry.cc',
     'src/core/ext/filters/client_channel/local_subchannel_pool.cc',
     'src/core/ext/filters/client_channel/proxy_mapper_registry.cc',
@@ -70,8 +70,8 @@ CORE_SOURCE_FILES = [
     'src/core/ext/filters/client_channel/retry_throttle.cc',
     'src/core/ext/filters/client_channel/server_address.cc',
     'src/core/ext/filters/client_channel/service_config.cc',
-    'src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc', 
-    'src/core/ext/filters/client_channel/service_config_parser.cc', 
+    'src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc',
+    'src/core/ext/filters/client_channel/service_config_parser.cc',
     'src/core/ext/filters/client_channel/subchannel.cc',
     'src/core/ext/filters/client_channel/subchannel_pool_interface.cc',
     'src/core/ext/filters/client_idle/client_idle_filter.cc',
@@ -80,7 +80,7 @@ CORE_SOURCE_FILES = [
     'src/core/ext/filters/http/client_authority_filter.cc',
     'src/core/ext/filters/http/http_filters_plugin.cc',
     'src/core/ext/filters/http/message_compress/message_compress_filter.cc',
-    'src/core/ext/filters/http/message_compress/message_decompress_filter.cc', 
+    'src/core/ext/filters/http/message_compress/message_decompress_filter.cc',
     'src/core/ext/filters/http/server/http_server_filter.cc',
     'src/core/ext/filters/max_age/max_age_filter.cc',
     'src/core/ext/filters/message_size/message_size_filter.cc',
@@ -121,66 +121,66 @@ CORE_SOURCE_FILES = [
     'src/core/ext/transport/chttp2/transport/writing.cc',
     'src/core/ext/transport/inproc/inproc_plugin.cc',
     'src/core/ext/transport/inproc/inproc_transport.cc',
-    'src/core/ext/upb-generated/envoy/annotations/deprecation.upb.c', 
-    'src/core/ext/upb-generated/envoy/annotations/resource.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/accesslog/v3/accesslog.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/cluster/v3/circuit_breaker.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/cluster/v3/cluster.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/cluster/v3/filter.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/cluster/v3/outlier_detection.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/address.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/backoff.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/base.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/config_source.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/event_service_config.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/extension.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/grpc_service.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/health_check.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/http_uri.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/protocol.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/proxy_protocol.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/socket_option.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/core/v3/substitution_format_string.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/endpoint/v3/endpoint.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/endpoint/v3/endpoint_components.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/endpoint/v3/load_report.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/listener/v3/api_listener.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/listener/v3/listener.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/listener/v3/listener_components.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/listener/v3/udp_listener_config.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/rbac/v3/rbac.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/route/v3/route.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/route/v3/route_components.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/route/v3/scoped_route.upb.c', 
-    'src/core/ext/upb-generated/envoy/config/trace/v3/http_tracer.upb.c', 
-    'src/core/ext/upb-generated/envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upb.c', 
-    'src/core/ext/upb-generated/envoy/extensions/transport_sockets/tls/v3/cert.upb.c', 
-    'src/core/ext/upb-generated/envoy/extensions/transport_sockets/tls/v3/common.upb.c', 
-    'src/core/ext/upb-generated/envoy/extensions/transport_sockets/tls/v3/secret.upb.c', 
-    'src/core/ext/upb-generated/envoy/extensions/transport_sockets/tls/v3/tls.upb.c', 
-    'src/core/ext/upb-generated/envoy/service/cluster/v3/cds.upb.c', 
-    'src/core/ext/upb-generated/envoy/service/discovery/v3/ads.upb.c', 
-    'src/core/ext/upb-generated/envoy/service/discovery/v3/discovery.upb.c', 
-    'src/core/ext/upb-generated/envoy/service/endpoint/v3/eds.upb.c', 
-    'src/core/ext/upb-generated/envoy/service/listener/v3/lds.upb.c', 
-    'src/core/ext/upb-generated/envoy/service/load_stats/v3/lrs.upb.c', 
-    'src/core/ext/upb-generated/envoy/service/route/v3/rds.upb.c', 
-    'src/core/ext/upb-generated/envoy/service/route/v3/srds.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/matcher/v3/metadata.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/matcher/v3/number.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/matcher/v3/path.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/matcher/v3/regex.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/matcher/v3/string.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/matcher/v3/value.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/metadata/v3/metadata.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/tracing/v3/custom_tag.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/v3/http.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/v3/percent.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/v3/range.upb.c', 
-    'src/core/ext/upb-generated/envoy/type/v3/semantic_version.upb.c', 
+    'src/core/ext/upb-generated/envoy/annotations/deprecation.upb.c',
+    'src/core/ext/upb-generated/envoy/annotations/resource.upb.c',
+    'src/core/ext/upb-generated/envoy/config/accesslog/v3/accesslog.upb.c',
+    'src/core/ext/upb-generated/envoy/config/cluster/v3/circuit_breaker.upb.c',
+    'src/core/ext/upb-generated/envoy/config/cluster/v3/cluster.upb.c',
+    'src/core/ext/upb-generated/envoy/config/cluster/v3/filter.upb.c',
+    'src/core/ext/upb-generated/envoy/config/cluster/v3/outlier_detection.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/address.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/backoff.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/base.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/config_source.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/event_service_config.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/extension.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/grpc_service.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/health_check.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/http_uri.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/protocol.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/proxy_protocol.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/socket_option.upb.c',
+    'src/core/ext/upb-generated/envoy/config/core/v3/substitution_format_string.upb.c',
+    'src/core/ext/upb-generated/envoy/config/endpoint/v3/endpoint.upb.c',
+    'src/core/ext/upb-generated/envoy/config/endpoint/v3/endpoint_components.upb.c',
+    'src/core/ext/upb-generated/envoy/config/endpoint/v3/load_report.upb.c',
+    'src/core/ext/upb-generated/envoy/config/listener/v3/api_listener.upb.c',
+    'src/core/ext/upb-generated/envoy/config/listener/v3/listener.upb.c',
+    'src/core/ext/upb-generated/envoy/config/listener/v3/listener_components.upb.c',
+    'src/core/ext/upb-generated/envoy/config/listener/v3/udp_listener_config.upb.c',
+    'src/core/ext/upb-generated/envoy/config/rbac/v3/rbac.upb.c',
+    'src/core/ext/upb-generated/envoy/config/route/v3/route.upb.c',
+    'src/core/ext/upb-generated/envoy/config/route/v3/route_components.upb.c',
+    'src/core/ext/upb-generated/envoy/config/route/v3/scoped_route.upb.c',
+    'src/core/ext/upb-generated/envoy/config/trace/v3/http_tracer.upb.c',
+    'src/core/ext/upb-generated/envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upb.c',
+    'src/core/ext/upb-generated/envoy/extensions/transport_sockets/tls/v3/cert.upb.c',
+    'src/core/ext/upb-generated/envoy/extensions/transport_sockets/tls/v3/common.upb.c',
+    'src/core/ext/upb-generated/envoy/extensions/transport_sockets/tls/v3/secret.upb.c',
+    'src/core/ext/upb-generated/envoy/extensions/transport_sockets/tls/v3/tls.upb.c',
+    'src/core/ext/upb-generated/envoy/service/cluster/v3/cds.upb.c',
+    'src/core/ext/upb-generated/envoy/service/discovery/v3/ads.upb.c',
+    'src/core/ext/upb-generated/envoy/service/discovery/v3/discovery.upb.c',
+    'src/core/ext/upb-generated/envoy/service/endpoint/v3/eds.upb.c',
+    'src/core/ext/upb-generated/envoy/service/listener/v3/lds.upb.c',
+    'src/core/ext/upb-generated/envoy/service/load_stats/v3/lrs.upb.c',
+    'src/core/ext/upb-generated/envoy/service/route/v3/rds.upb.c',
+    'src/core/ext/upb-generated/envoy/service/route/v3/srds.upb.c',
+    'src/core/ext/upb-generated/envoy/type/matcher/v3/metadata.upb.c',
+    'src/core/ext/upb-generated/envoy/type/matcher/v3/number.upb.c',
+    'src/core/ext/upb-generated/envoy/type/matcher/v3/path.upb.c',
+    'src/core/ext/upb-generated/envoy/type/matcher/v3/regex.upb.c',
+    'src/core/ext/upb-generated/envoy/type/matcher/v3/string.upb.c',
+    'src/core/ext/upb-generated/envoy/type/matcher/v3/value.upb.c',
+    'src/core/ext/upb-generated/envoy/type/metadata/v3/metadata.upb.c',
+    'src/core/ext/upb-generated/envoy/type/tracing/v3/custom_tag.upb.c',
+    'src/core/ext/upb-generated/envoy/type/v3/http.upb.c',
+    'src/core/ext/upb-generated/envoy/type/v3/percent.upb.c',
+    'src/core/ext/upb-generated/envoy/type/v3/range.upb.c',
+    'src/core/ext/upb-generated/envoy/type/v3/semantic_version.upb.c',
     'src/core/ext/upb-generated/google/api/annotations.upb.c',
-    'src/core/ext/upb-generated/google/api/expr/v1alpha1/checked.upb.c', 
-    'src/core/ext/upb-generated/google/api/expr/v1alpha1/syntax.upb.c', 
+    'src/core/ext/upb-generated/google/api/expr/v1alpha1/checked.upb.c',
+    'src/core/ext/upb-generated/google/api/expr/v1alpha1/syntax.upb.c',
     'src/core/ext/upb-generated/google/api/http.upb.c',
     'src/core/ext/upb-generated/google/protobuf/any.upb.c',
     'src/core/ext/upb-generated/google/protobuf/descriptor.upb.c',
@@ -195,25 +195,25 @@ CORE_SOURCE_FILES = [
     'src/core/ext/upb-generated/src/proto/grpc/gcp/transport_security_common.upb.c',
     'src/core/ext/upb-generated/src/proto/grpc/health/v1/health.upb.c',
     'src/core/ext/upb-generated/src/proto/grpc/lb/v1/load_balancer.upb.c',
-    'src/core/ext/upb-generated/udpa/annotations/migrate.upb.c', 
-    'src/core/ext/upb-generated/udpa/annotations/security.upb.c', 
-    'src/core/ext/upb-generated/udpa/annotations/sensitive.upb.c', 
-    'src/core/ext/upb-generated/udpa/annotations/status.upb.c', 
-    'src/core/ext/upb-generated/udpa/annotations/versioning.upb.c', 
-    'src/core/ext/upb-generated/udpa/core/v1/authority.upb.c', 
-    'src/core/ext/upb-generated/udpa/core/v1/collection_entry.upb.c', 
-    'src/core/ext/upb-generated/udpa/core/v1/context_params.upb.c', 
-    'src/core/ext/upb-generated/udpa/core/v1/resource.upb.c', 
-    'src/core/ext/upb-generated/udpa/core/v1/resource_locator.upb.c', 
-    'src/core/ext/upb-generated/udpa/core/v1/resource_name.upb.c', 
+    'src/core/ext/upb-generated/udpa/annotations/migrate.upb.c',
+    'src/core/ext/upb-generated/udpa/annotations/security.upb.c',
+    'src/core/ext/upb-generated/udpa/annotations/sensitive.upb.c',
+    'src/core/ext/upb-generated/udpa/annotations/status.upb.c',
+    'src/core/ext/upb-generated/udpa/annotations/versioning.upb.c',
+    'src/core/ext/upb-generated/udpa/core/v1/authority.upb.c',
+    'src/core/ext/upb-generated/udpa/core/v1/collection_entry.upb.c',
+    'src/core/ext/upb-generated/udpa/core/v1/context_params.upb.c',
+    'src/core/ext/upb-generated/udpa/core/v1/resource.upb.c',
+    'src/core/ext/upb-generated/udpa/core/v1/resource_locator.upb.c',
+    'src/core/ext/upb-generated/udpa/core/v1/resource_name.upb.c',
     'src/core/ext/upb-generated/udpa/data/orca/v1/orca_load_report.upb.c',
     'src/core/ext/upb-generated/validate/validate.upb.c',
-    'src/core/ext/xds/certificate_provider_registry.cc', 
-    'src/core/ext/xds/google_mesh_ca_certificate_provider_factory.cc', 
-    'src/core/ext/xds/xds_api.cc', 
-    'src/core/ext/xds/xds_bootstrap.cc', 
-    'src/core/ext/xds/xds_client.cc', 
-    'src/core/ext/xds/xds_client_stats.cc', 
+    'src/core/ext/xds/certificate_provider_registry.cc',
+    'src/core/ext/xds/google_mesh_ca_certificate_provider_factory.cc',
+    'src/core/ext/xds/xds_api.cc',
+    'src/core/ext/xds/xds_bootstrap.cc',
+    'src/core/ext/xds/xds_client.cc',
+    'src/core/ext/xds/xds_client_stats.cc',
     'src/core/lib/avl/avl.cc',
     'src/core/lib/backoff/backoff.cc',
     'src/core/lib/channel/channel_args.cc',
@@ -256,7 +256,7 @@ CORE_SOURCE_FILES = [
     'src/core/lib/gpr/string_util_windows.cc',
     'src/core/lib/gpr/string_windows.cc',
     'src/core/lib/gpr/sync.cc',
-    'src/core/lib/gpr/sync_abseil.cc', 
+    'src/core/lib/gpr/sync_abseil.cc',
     'src/core/lib/gpr/sync_posix.cc',
     'src/core/lib/gpr/sync_windows.cc',
     'src/core/lib/gpr/time.cc',
@@ -283,7 +283,7 @@ CORE_SOURCE_FILES = [
     'src/core/lib/iomgr/call_combiner.cc',
     'src/core/lib/iomgr/cfstream_handle.cc',
     'src/core/lib/iomgr/combiner.cc',
-    'src/core/lib/iomgr/dualstack_socket_posix.cc', 
+    'src/core/lib/iomgr/dualstack_socket_posix.cc',
     'src/core/lib/iomgr/endpoint.cc',
     'src/core/lib/iomgr/endpoint_cfstream.cc',
     'src/core/lib/iomgr/endpoint_pair_posix.cc',
@@ -291,7 +291,7 @@ CORE_SOURCE_FILES = [
     'src/core/lib/iomgr/endpoint_pair_windows.cc',
     'src/core/lib/iomgr/error.cc',
     'src/core/lib/iomgr/error_cfstream.cc',
-    'src/core/lib/iomgr/ev_apple.cc', 
+    'src/core/lib/iomgr/ev_apple.cc',
     'src/core/lib/iomgr/ev_epoll1_linux.cc',
     'src/core/lib/iomgr/ev_epollex_linux.cc',
     'src/core/lib/iomgr/ev_poll_posix.cc',
@@ -320,8 +320,8 @@ CORE_SOURCE_FILES = [
     'src/core/lib/iomgr/is_epollexclusive_available.cc',
     'src/core/lib/iomgr/load_file.cc',
     'src/core/lib/iomgr/lockfree_event.cc',
-    'src/core/lib/iomgr/parse_address.cc', 
-    'src/core/lib/iomgr/poller/eventmanager_libuv.cc', 
+    'src/core/lib/iomgr/parse_address.cc',
+    'src/core/lib/iomgr/poller/eventmanager_libuv.cc',
     'src/core/lib/iomgr/polling_entity.cc',
     'src/core/lib/iomgr/pollset.cc',
     'src/core/lib/iomgr/pollset_custom.cc',
@@ -374,14 +374,14 @@ CORE_SOURCE_FILES = [
     'src/core/lib/iomgr/wakeup_fd_nospecial.cc',
     'src/core/lib/iomgr/wakeup_fd_pipe.cc',
     'src/core/lib/iomgr/wakeup_fd_posix.cc',
-    'src/core/lib/iomgr/work_serializer.cc', 
+    'src/core/lib/iomgr/work_serializer.cc',
     'src/core/lib/json/json_reader.cc',
-    'src/core/lib/json/json_util.cc', 
+    'src/core/lib/json/json_util.cc',
     'src/core/lib/json/json_writer.cc',
     'src/core/lib/profiling/basic_timers.cc',
     'src/core/lib/profiling/stap_timers.cc',
-    'src/core/lib/security/authorization/authorization_engine.cc', 
-    'src/core/lib/security/authorization/evaluate_args.cc', 
+    'src/core/lib/security/authorization/authorization_engine.cc',
+    'src/core/lib/security/authorization/evaluate_args.cc',
     'src/core/lib/security/context/security_context.cc',
     'src/core/lib/security/credentials/alts/alts_credentials.cc',
     'src/core/lib/security/credentials/alts/check_gcp_environment.cc',
@@ -405,10 +405,10 @@ CORE_SOURCE_FILES = [
     'src/core/lib/security/credentials/oauth2/oauth2_credentials.cc',
     'src/core/lib/security/credentials/plugin/plugin_credentials.cc',
     'src/core/lib/security/credentials/ssl/ssl_credentials.cc',
-    'src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.cc', 
+    'src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.cc',
     'src/core/lib/security/credentials/tls/grpc_tls_credentials_options.cc',
-    'src/core/lib/security/credentials/tls/tls_credentials.cc', 
-    'src/core/lib/security/credentials/xds/xds_credentials.cc', 
+    'src/core/lib/security/credentials/tls/tls_credentials.cc',
+    'src/core/lib/security/credentials/xds/xds_credentials.cc',
     'src/core/lib/security/security_connector/alts/alts_security_connector.cc',
     'src/core/lib/security/security_connector/fake/fake_security_connector.cc',
     'src/core/lib/security/security_connector/load_system_roots_fallback.cc',
@@ -418,7 +418,7 @@ CORE_SOURCE_FILES = [
     'src/core/lib/security/security_connector/ssl/ssl_security_connector.cc',
     'src/core/lib/security/security_connector/ssl_utils.cc',
     'src/core/lib/security/security_connector/ssl_utils_config.cc',
-    'src/core/lib/security/security_connector/tls/tls_security_connector.cc', 
+    'src/core/lib/security/security_connector/tls/tls_security_connector.cc',
     'src/core/lib/security/transport/client_auth_filter.cc',
     'src/core/lib/security/transport/secure_endpoint.cc',
     'src/core/lib/security/transport/security_handshaker.cc',
@@ -451,7 +451,7 @@ CORE_SOURCE_FILES = [
     'src/core/lib/surface/server.cc',
     'src/core/lib/surface/validate_metadata.cc',
     'src/core/lib/surface/version.cc',
-    'src/core/lib/transport/authority_override.cc', 
+    'src/core/lib/transport/authority_override.cc',
     'src/core/lib/transport/bdp_estimator.cc',
     'src/core/lib/transport/byte_stream.cc',
     'src/core/lib/transport/connectivity_state.cc',
@@ -494,349 +494,349 @@ CORE_SOURCE_FILES = [
     'src/core/tsi/ssl_transport_security.cc',
     'src/core/tsi/transport_security.cc',
     'src/core/tsi/transport_security_grpc.cc',
-    'third_party/abseil-cpp/y_absl/base/dynamic_annotations.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/cycleclock.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/exponential_biased.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/low_level_alloc.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/raw_logging.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/spinlock.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/spinlock_wait.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/sysinfo.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/thread_identity.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/throw_delegate.cc', 
-    'third_party/abseil-cpp/y_absl/base/internal/unscaledcycleclock.cc', 
-    'third_party/abseil-cpp/y_absl/base/log_severity.cc', 
-    'third_party/abseil-cpp/y_absl/container/internal/hashtablez_sampler.cc', 
-    'third_party/abseil-cpp/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc', 
-    'third_party/abseil-cpp/y_absl/container/internal/raw_hash_set.cc', 
-    'third_party/abseil-cpp/y_absl/debugging/internal/address_is_readable.cc', 
-    'third_party/abseil-cpp/y_absl/debugging/internal/demangle.cc', 
-    'third_party/abseil-cpp/y_absl/debugging/internal/elf_mem_image.cc', 
-    'third_party/abseil-cpp/y_absl/debugging/internal/vdso_support.cc', 
-    'third_party/abseil-cpp/y_absl/debugging/stacktrace.cc', 
-    'third_party/abseil-cpp/y_absl/debugging/symbolize.cc', 
-    'third_party/abseil-cpp/y_absl/hash/internal/city.cc', 
-    'third_party/abseil-cpp/y_absl/hash/internal/hash.cc', 
-    'third_party/abseil-cpp/y_absl/numeric/int128.cc', 
-    'third_party/abseil-cpp/y_absl/status/status.cc', 
-    'third_party/abseil-cpp/y_absl/status/status_payload_printer.cc', 
-    'third_party/abseil-cpp/y_absl/strings/ascii.cc', 
-    'third_party/abseil-cpp/y_absl/strings/charconv.cc', 
-    'third_party/abseil-cpp/y_absl/strings/cord.cc', 
-    'third_party/abseil-cpp/y_absl/strings/escaping.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/charconv_bigint.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/charconv_parse.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/escaping.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/memutil.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/ostringstream.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/str_format/arg.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/str_format/bind.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/str_format/extension.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/str_format/float_conversion.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/str_format/output.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/str_format/parser.cc', 
-    'third_party/abseil-cpp/y_absl/strings/internal/utf8.cc', 
-    'third_party/abseil-cpp/y_absl/strings/match.cc', 
-    'third_party/abseil-cpp/y_absl/strings/numbers.cc', 
-    'third_party/abseil-cpp/y_absl/strings/str_cat.cc', 
-    'third_party/abseil-cpp/y_absl/strings/str_replace.cc', 
-    'third_party/abseil-cpp/y_absl/strings/str_split.cc', 
-    'third_party/abseil-cpp/y_absl/strings/string_view.cc', 
-    'third_party/abseil-cpp/y_absl/strings/substitute.cc', 
-    'third_party/abseil-cpp/y_absl/synchronization/barrier.cc', 
-    'third_party/abseil-cpp/y_absl/synchronization/blocking_counter.cc', 
-    'third_party/abseil-cpp/y_absl/synchronization/internal/create_thread_identity.cc', 
-    'third_party/abseil-cpp/y_absl/synchronization/internal/graphcycles.cc', 
-    'third_party/abseil-cpp/y_absl/synchronization/internal/per_thread_sem.cc', 
-    'third_party/abseil-cpp/y_absl/synchronization/internal/waiter.cc', 
-    'third_party/abseil-cpp/y_absl/synchronization/mutex.cc', 
-    'third_party/abseil-cpp/y_absl/synchronization/notification.cc', 
-    'third_party/abseil-cpp/y_absl/time/civil_time.cc', 
-    'third_party/abseil-cpp/y_absl/time/clock.cc', 
-    'third_party/abseil-cpp/y_absl/time/duration.cc', 
-    'third_party/abseil-cpp/y_absl/time/format.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/civil_time_detail.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_fixed.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_format.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_if.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_impl.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_info.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_libc.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_lookup.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_posix.cc', 
-    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/zone_info_source.cc', 
-    'third_party/abseil-cpp/y_absl/time/time.cc', 
-    'third_party/abseil-cpp/y_absl/types/bad_optional_access.cc', 
-    'third_party/abseil-cpp/y_absl/types/bad_variant_access.cc', 
+    'third_party/abseil-cpp/y_absl/base/dynamic_annotations.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/cycleclock.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/exponential_biased.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/low_level_alloc.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/raw_logging.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/spinlock.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/spinlock_wait.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/sysinfo.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/thread_identity.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/throw_delegate.cc',
+    'third_party/abseil-cpp/y_absl/base/internal/unscaledcycleclock.cc',
+    'third_party/abseil-cpp/y_absl/base/log_severity.cc',
+    'third_party/abseil-cpp/y_absl/container/internal/hashtablez_sampler.cc',
+    'third_party/abseil-cpp/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc',
+    'third_party/abseil-cpp/y_absl/container/internal/raw_hash_set.cc',
+    'third_party/abseil-cpp/y_absl/debugging/internal/address_is_readable.cc',
+    'third_party/abseil-cpp/y_absl/debugging/internal/demangle.cc',
+    'third_party/abseil-cpp/y_absl/debugging/internal/elf_mem_image.cc',
+    'third_party/abseil-cpp/y_absl/debugging/internal/vdso_support.cc',
+    'third_party/abseil-cpp/y_absl/debugging/stacktrace.cc',
+    'third_party/abseil-cpp/y_absl/debugging/symbolize.cc',
+    'third_party/abseil-cpp/y_absl/hash/internal/city.cc',
+    'third_party/abseil-cpp/y_absl/hash/internal/hash.cc',
+    'third_party/abseil-cpp/y_absl/numeric/int128.cc',
+    'third_party/abseil-cpp/y_absl/status/status.cc',
+    'third_party/abseil-cpp/y_absl/status/status_payload_printer.cc',
+    'third_party/abseil-cpp/y_absl/strings/ascii.cc',
+    'third_party/abseil-cpp/y_absl/strings/charconv.cc',
+    'third_party/abseil-cpp/y_absl/strings/cord.cc',
+    'third_party/abseil-cpp/y_absl/strings/escaping.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/charconv_bigint.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/charconv_parse.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/escaping.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/memutil.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/ostringstream.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/str_format/arg.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/str_format/bind.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/str_format/extension.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/str_format/float_conversion.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/str_format/output.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/str_format/parser.cc',
+    'third_party/abseil-cpp/y_absl/strings/internal/utf8.cc',
+    'third_party/abseil-cpp/y_absl/strings/match.cc',
+    'third_party/abseil-cpp/y_absl/strings/numbers.cc',
+    'third_party/abseil-cpp/y_absl/strings/str_cat.cc',
+    'third_party/abseil-cpp/y_absl/strings/str_replace.cc',
+    'third_party/abseil-cpp/y_absl/strings/str_split.cc',
+    'third_party/abseil-cpp/y_absl/strings/string_view.cc',
+    'third_party/abseil-cpp/y_absl/strings/substitute.cc',
+    'third_party/abseil-cpp/y_absl/synchronization/barrier.cc',
+    'third_party/abseil-cpp/y_absl/synchronization/blocking_counter.cc',
+    'third_party/abseil-cpp/y_absl/synchronization/internal/create_thread_identity.cc',
+    'third_party/abseil-cpp/y_absl/synchronization/internal/graphcycles.cc',
+    'third_party/abseil-cpp/y_absl/synchronization/internal/per_thread_sem.cc',
+    'third_party/abseil-cpp/y_absl/synchronization/internal/waiter.cc',
+    'third_party/abseil-cpp/y_absl/synchronization/mutex.cc',
+    'third_party/abseil-cpp/y_absl/synchronization/notification.cc',
+    'third_party/abseil-cpp/y_absl/time/civil_time.cc',
+    'third_party/abseil-cpp/y_absl/time/clock.cc',
+    'third_party/abseil-cpp/y_absl/time/duration.cc',
+    'third_party/abseil-cpp/y_absl/time/format.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/civil_time_detail.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_fixed.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_format.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_if.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_impl.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_info.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_libc.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_lookup.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/time_zone_posix.cc',
+    'third_party/abseil-cpp/y_absl/time/internal/cctz/src/zone_info_source.cc',
+    'third_party/abseil-cpp/y_absl/time/time.cc',
+    'third_party/abseil-cpp/y_absl/types/bad_optional_access.cc',
+    'third_party/abseil-cpp/y_absl/types/bad_variant_access.cc',
     'third_party/address_sorting/address_sorting.c',
     'third_party/address_sorting/address_sorting_posix.c',
     'third_party/address_sorting/address_sorting_windows.c',
-    'third_party/boringssl-with-bazel/err_data.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_bitstr.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_bool.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_d2i_fp.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_dup.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_enum.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_gentm.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_i2d_fp.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_int.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_mbstr.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_object.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_octet.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_print.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_strnid.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_time.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_type.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_utctm.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/a_utf8.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/asn1_lib.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/asn1_par.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/asn_pack.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/f_enum.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/f_int.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/f_string.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_dec.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_enc.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_fre.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_new.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_typ.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_utl.c', 
-    'third_party/boringssl-with-bazel/src/crypto/asn1/time_support.c', 
-    'third_party/boringssl-with-bazel/src/crypto/base64/base64.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/bio.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/bio_mem.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/connect.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/fd.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/file.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/hexdump.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/pair.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/printf.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/socket.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bio/socket_helper.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bn_extra/bn_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bn_extra/convert.c', 
-    'third_party/boringssl-with-bazel/src/crypto/buf/buf.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bytestring/asn1_compat.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bytestring/ber.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bytestring/cbb.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bytestring/cbs.c', 
-    'third_party/boringssl-with-bazel/src/crypto/bytestring/unicode.c', 
-    'third_party/boringssl-with-bazel/src/crypto/chacha/chacha.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/cipher_extra.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/derive_key.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_aesccm.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_aesctrhmac.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_aesgcmsiv.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_chacha20poly1305.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_null.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_rc2.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_rc4.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_tls.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/tls_cbc.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cmac/cmac.c', 
-    'third_party/boringssl-with-bazel/src/crypto/conf/conf.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cpu-aarch64-fuchsia.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cpu-aarch64-linux.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cpu-arm-linux.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cpu-arm.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cpu-intel.c', 
-    'third_party/boringssl-with-bazel/src/crypto/cpu-ppc64le.c', 
-    'third_party/boringssl-with-bazel/src/crypto/crypto.c', 
-    'third_party/boringssl-with-bazel/src/crypto/curve25519/curve25519.c', 
-    'third_party/boringssl-with-bazel/src/crypto/curve25519/spake25519.c', 
-    'third_party/boringssl-with-bazel/src/crypto/dh/check.c', 
-    'third_party/boringssl-with-bazel/src/crypto/dh/dh.c', 
-    'third_party/boringssl-with-bazel/src/crypto/dh/dh_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/dh/params.c', 
-    'third_party/boringssl-with-bazel/src/crypto/digest_extra/digest_extra.c', 
-    'third_party/boringssl-with-bazel/src/crypto/dsa/dsa.c', 
-    'third_party/boringssl-with-bazel/src/crypto/dsa/dsa_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/ec_extra/ec_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/ec_extra/ec_derive.c', 
-    'third_party/boringssl-with-bazel/src/crypto/ec_extra/hash_to_curve.c', 
-    'third_party/boringssl-with-bazel/src/crypto/ecdh_extra/ecdh_extra.c', 
-    'third_party/boringssl-with-bazel/src/crypto/ecdsa_extra/ecdsa_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/engine/engine.c', 
-    'third_party/boringssl-with-bazel/src/crypto/err/err.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/digestsign.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/evp.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/evp_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/evp_ctx.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_dsa_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_ec.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_ec_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_ed25519.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_ed25519_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_rsa.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_rsa_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_x25519.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/p_x25519_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/pbkdf.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/print.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/scrypt.c', 
-    'third_party/boringssl-with-bazel/src/crypto/evp/sign.c', 
-    'third_party/boringssl-with-bazel/src/crypto/ex_data.c', 
-    'third_party/boringssl-with-bazel/src/crypto/fipsmodule/bcm.c', 
-    'third_party/boringssl-with-bazel/src/crypto/fipsmodule/fips_shared_support.c', 
-    'third_party/boringssl-with-bazel/src/crypto/fipsmodule/is_fips.c', 
-    'third_party/boringssl-with-bazel/src/crypto/hkdf/hkdf.c', 
-    'third_party/boringssl-with-bazel/src/crypto/hpke/hpke.c', 
-    'third_party/boringssl-with-bazel/src/crypto/hrss/hrss.c', 
-    'third_party/boringssl-with-bazel/src/crypto/lhash/lhash.c', 
-    'third_party/boringssl-with-bazel/src/crypto/mem.c', 
-    'third_party/boringssl-with-bazel/src/crypto/obj/obj.c', 
-    'third_party/boringssl-with-bazel/src/crypto/obj/obj_xref.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pem/pem_all.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pem/pem_info.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pem/pem_lib.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pem/pem_oth.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pem/pem_pk8.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pem/pem_pkey.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pem/pem_x509.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pem/pem_xaux.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pkcs7/pkcs7.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pkcs7/pkcs7_x509.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pkcs8/p5_pbev2.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pkcs8/pkcs8.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pkcs8/pkcs8_x509.c', 
-    'third_party/boringssl-with-bazel/src/crypto/poly1305/poly1305.c', 
-    'third_party/boringssl-with-bazel/src/crypto/poly1305/poly1305_arm.c', 
-    'third_party/boringssl-with-bazel/src/crypto/poly1305/poly1305_vec.c', 
-    'third_party/boringssl-with-bazel/src/crypto/pool/pool.c', 
-    'third_party/boringssl-with-bazel/src/crypto/rand_extra/deterministic.c', 
-    'third_party/boringssl-with-bazel/src/crypto/rand_extra/forkunsafe.c', 
-    'third_party/boringssl-with-bazel/src/crypto/rand_extra/fuchsia.c', 
-    'third_party/boringssl-with-bazel/src/crypto/rand_extra/rand_extra.c', 
-    'third_party/boringssl-with-bazel/src/crypto/rand_extra/windows.c', 
-    'third_party/boringssl-with-bazel/src/crypto/rc4/rc4.c', 
-    'third_party/boringssl-with-bazel/src/crypto/refcount_c11.c', 
-    'third_party/boringssl-with-bazel/src/crypto/refcount_lock.c', 
-    'third_party/boringssl-with-bazel/src/crypto/rsa_extra/rsa_asn1.c', 
-    'third_party/boringssl-with-bazel/src/crypto/rsa_extra/rsa_print.c', 
-    'third_party/boringssl-with-bazel/src/crypto/siphash/siphash.c', 
-    'third_party/boringssl-with-bazel/src/crypto/stack/stack.c', 
-    'third_party/boringssl-with-bazel/src/crypto/thread.c', 
-    'third_party/boringssl-with-bazel/src/crypto/thread_none.c', 
-    'third_party/boringssl-with-bazel/src/crypto/thread_pthread.c', 
-    'third_party/boringssl-with-bazel/src/crypto/thread_win.c', 
-    'third_party/boringssl-with-bazel/src/crypto/trust_token/pmbtoken.c', 
-    'third_party/boringssl-with-bazel/src/crypto/trust_token/trust_token.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/a_digest.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/a_sign.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/a_strex.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/a_verify.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/algorithm.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/asn1_gen.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/by_dir.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/by_file.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/i2d_pr.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/rsa_pss.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/t_crl.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/t_req.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/t_x509.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/t_x509a.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_att.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_cmp.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_d2.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_def.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_ext.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_lu.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_obj.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_r2x.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_req.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_set.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_trs.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_txt.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_v3.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_vfy.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509_vpm.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509cset.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509name.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509rset.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x509spki.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_algor.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_all.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_attrib.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_crl.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_exten.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_info.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_name.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_pkey.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_pubkey.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_req.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_sig.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_spki.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_val.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_x509.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509/x_x509a.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_cache.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_data.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_lib.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_map.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_node.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_tree.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_akey.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_akeya.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_alt.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_bcons.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_bitst.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_conf.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_cpols.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_crld.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_enum.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_extku.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_genn.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_ia5.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_info.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_int.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_lib.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_ncons.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_ocsp.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_pci.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_pcia.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_pcons.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_pmaps.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_prn.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_purp.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_skey.c', 
-    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_utl.c', 
-    'third_party/boringssl-with-bazel/src/ssl/bio_ssl.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/d1_both.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/d1_lib.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/d1_pkt.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/d1_srtp.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/dtls_method.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/dtls_record.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/handoff.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/handshake.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/handshake_client.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/handshake_server.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/s3_both.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/s3_lib.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/s3_pkt.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_aead_ctx.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_asn1.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_buffer.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_cert.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_cipher.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_file.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_key_share.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_lib.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_privkey.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_session.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_stat.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_transcript.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_versions.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/ssl_x509.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/t1_enc.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/t1_lib.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/tls13_both.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/tls13_client.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/tls13_enc.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/tls13_server.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/tls_method.cc', 
-    'third_party/boringssl-with-bazel/src/ssl/tls_record.cc', 
+    'third_party/boringssl-with-bazel/err_data.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_bitstr.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_bool.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_d2i_fp.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_dup.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_enum.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_gentm.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_i2d_fp.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_int.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_mbstr.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_object.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_octet.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_print.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_strnid.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_time.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_type.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_utctm.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/a_utf8.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/asn1_lib.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/asn1_par.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/asn_pack.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/f_enum.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/f_int.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/f_string.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_dec.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_enc.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_fre.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_new.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_typ.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/tasn_utl.c',
+    'third_party/boringssl-with-bazel/src/crypto/asn1/time_support.c',
+    'third_party/boringssl-with-bazel/src/crypto/base64/base64.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/bio.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/bio_mem.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/connect.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/fd.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/file.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/hexdump.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/pair.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/printf.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/socket.c',
+    'third_party/boringssl-with-bazel/src/crypto/bio/socket_helper.c',
+    'third_party/boringssl-with-bazel/src/crypto/bn_extra/bn_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/bn_extra/convert.c',
+    'third_party/boringssl-with-bazel/src/crypto/buf/buf.c',
+    'third_party/boringssl-with-bazel/src/crypto/bytestring/asn1_compat.c',
+    'third_party/boringssl-with-bazel/src/crypto/bytestring/ber.c',
+    'third_party/boringssl-with-bazel/src/crypto/bytestring/cbb.c',
+    'third_party/boringssl-with-bazel/src/crypto/bytestring/cbs.c',
+    'third_party/boringssl-with-bazel/src/crypto/bytestring/unicode.c',
+    'third_party/boringssl-with-bazel/src/crypto/chacha/chacha.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/cipher_extra.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/derive_key.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_aesccm.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_aesctrhmac.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_aesgcmsiv.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_chacha20poly1305.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_null.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_rc2.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_rc4.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_tls.c',
+    'third_party/boringssl-with-bazel/src/crypto/cipher_extra/tls_cbc.c',
+    'third_party/boringssl-with-bazel/src/crypto/cmac/cmac.c',
+    'third_party/boringssl-with-bazel/src/crypto/conf/conf.c',
+    'third_party/boringssl-with-bazel/src/crypto/cpu-aarch64-fuchsia.c',
+    'third_party/boringssl-with-bazel/src/crypto/cpu-aarch64-linux.c',
+    'third_party/boringssl-with-bazel/src/crypto/cpu-arm-linux.c',
+    'third_party/boringssl-with-bazel/src/crypto/cpu-arm.c',
+    'third_party/boringssl-with-bazel/src/crypto/cpu-intel.c',
+    'third_party/boringssl-with-bazel/src/crypto/cpu-ppc64le.c',
+    'third_party/boringssl-with-bazel/src/crypto/crypto.c',
+    'third_party/boringssl-with-bazel/src/crypto/curve25519/curve25519.c',
+    'third_party/boringssl-with-bazel/src/crypto/curve25519/spake25519.c',
+    'third_party/boringssl-with-bazel/src/crypto/dh/check.c',
+    'third_party/boringssl-with-bazel/src/crypto/dh/dh.c',
+    'third_party/boringssl-with-bazel/src/crypto/dh/dh_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/dh/params.c',
+    'third_party/boringssl-with-bazel/src/crypto/digest_extra/digest_extra.c',
+    'third_party/boringssl-with-bazel/src/crypto/dsa/dsa.c',
+    'third_party/boringssl-with-bazel/src/crypto/dsa/dsa_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/ec_extra/ec_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/ec_extra/ec_derive.c',
+    'third_party/boringssl-with-bazel/src/crypto/ec_extra/hash_to_curve.c',
+    'third_party/boringssl-with-bazel/src/crypto/ecdh_extra/ecdh_extra.c',
+    'third_party/boringssl-with-bazel/src/crypto/ecdsa_extra/ecdsa_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/engine/engine.c',
+    'third_party/boringssl-with-bazel/src/crypto/err/err.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/digestsign.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/evp.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/evp_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/evp_ctx.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_dsa_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_ec.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_ec_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_ed25519.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_ed25519_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_rsa.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_rsa_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_x25519.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/p_x25519_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/pbkdf.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/print.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/scrypt.c',
+    'third_party/boringssl-with-bazel/src/crypto/evp/sign.c',
+    'third_party/boringssl-with-bazel/src/crypto/ex_data.c',
+    'third_party/boringssl-with-bazel/src/crypto/fipsmodule/bcm.c',
+    'third_party/boringssl-with-bazel/src/crypto/fipsmodule/fips_shared_support.c',
+    'third_party/boringssl-with-bazel/src/crypto/fipsmodule/is_fips.c',
+    'third_party/boringssl-with-bazel/src/crypto/hkdf/hkdf.c',
+    'third_party/boringssl-with-bazel/src/crypto/hpke/hpke.c',
+    'third_party/boringssl-with-bazel/src/crypto/hrss/hrss.c',
+    'third_party/boringssl-with-bazel/src/crypto/lhash/lhash.c',
+    'third_party/boringssl-with-bazel/src/crypto/mem.c',
+    'third_party/boringssl-with-bazel/src/crypto/obj/obj.c',
+    'third_party/boringssl-with-bazel/src/crypto/obj/obj_xref.c',
+    'third_party/boringssl-with-bazel/src/crypto/pem/pem_all.c',
+    'third_party/boringssl-with-bazel/src/crypto/pem/pem_info.c',
+    'third_party/boringssl-with-bazel/src/crypto/pem/pem_lib.c',
+    'third_party/boringssl-with-bazel/src/crypto/pem/pem_oth.c',
+    'third_party/boringssl-with-bazel/src/crypto/pem/pem_pk8.c',
+    'third_party/boringssl-with-bazel/src/crypto/pem/pem_pkey.c',
+    'third_party/boringssl-with-bazel/src/crypto/pem/pem_x509.c',
+    'third_party/boringssl-with-bazel/src/crypto/pem/pem_xaux.c',
+    'third_party/boringssl-with-bazel/src/crypto/pkcs7/pkcs7.c',
+    'third_party/boringssl-with-bazel/src/crypto/pkcs7/pkcs7_x509.c',
+    'third_party/boringssl-with-bazel/src/crypto/pkcs8/p5_pbev2.c',
+    'third_party/boringssl-with-bazel/src/crypto/pkcs8/pkcs8.c',
+    'third_party/boringssl-with-bazel/src/crypto/pkcs8/pkcs8_x509.c',
+    'third_party/boringssl-with-bazel/src/crypto/poly1305/poly1305.c',
+    'third_party/boringssl-with-bazel/src/crypto/poly1305/poly1305_arm.c',
+    'third_party/boringssl-with-bazel/src/crypto/poly1305/poly1305_vec.c',
+    'third_party/boringssl-with-bazel/src/crypto/pool/pool.c',
+    'third_party/boringssl-with-bazel/src/crypto/rand_extra/deterministic.c',
+    'third_party/boringssl-with-bazel/src/crypto/rand_extra/forkunsafe.c',
+    'third_party/boringssl-with-bazel/src/crypto/rand_extra/fuchsia.c',
+    'third_party/boringssl-with-bazel/src/crypto/rand_extra/rand_extra.c',
+    'third_party/boringssl-with-bazel/src/crypto/rand_extra/windows.c',
+    'third_party/boringssl-with-bazel/src/crypto/rc4/rc4.c',
+    'third_party/boringssl-with-bazel/src/crypto/refcount_c11.c',
+    'third_party/boringssl-with-bazel/src/crypto/refcount_lock.c',
+    'third_party/boringssl-with-bazel/src/crypto/rsa_extra/rsa_asn1.c',
+    'third_party/boringssl-with-bazel/src/crypto/rsa_extra/rsa_print.c',
+    'third_party/boringssl-with-bazel/src/crypto/siphash/siphash.c',
+    'third_party/boringssl-with-bazel/src/crypto/stack/stack.c',
+    'third_party/boringssl-with-bazel/src/crypto/thread.c',
+    'third_party/boringssl-with-bazel/src/crypto/thread_none.c',
+    'third_party/boringssl-with-bazel/src/crypto/thread_pthread.c',
+    'third_party/boringssl-with-bazel/src/crypto/thread_win.c',
+    'third_party/boringssl-with-bazel/src/crypto/trust_token/pmbtoken.c',
+    'third_party/boringssl-with-bazel/src/crypto/trust_token/trust_token.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/a_digest.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/a_sign.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/a_strex.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/a_verify.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/algorithm.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/asn1_gen.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/by_dir.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/by_file.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/i2d_pr.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/rsa_pss.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/t_crl.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/t_req.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/t_x509.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/t_x509a.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_att.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_cmp.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_d2.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_def.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_ext.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_lu.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_obj.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_r2x.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_req.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_set.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_trs.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_txt.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_v3.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_vfy.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509_vpm.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509cset.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509name.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509rset.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x509spki.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_algor.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_all.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_attrib.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_crl.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_exten.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_info.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_name.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_pkey.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_pubkey.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_req.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_sig.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_spki.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_val.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_x509.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509/x_x509a.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_cache.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_data.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_lib.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_map.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_node.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/pcy_tree.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_akey.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_akeya.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_alt.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_bcons.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_bitst.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_conf.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_cpols.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_crld.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_enum.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_extku.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_genn.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_ia5.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_info.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_int.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_lib.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_ncons.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_ocsp.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_pci.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_pcia.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_pcons.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_pmaps.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_prn.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_purp.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_skey.c',
+    'third_party/boringssl-with-bazel/src/crypto/x509v3/v3_utl.c',
+    'third_party/boringssl-with-bazel/src/ssl/bio_ssl.cc',
+    'third_party/boringssl-with-bazel/src/ssl/d1_both.cc',
+    'third_party/boringssl-with-bazel/src/ssl/d1_lib.cc',
+    'third_party/boringssl-with-bazel/src/ssl/d1_pkt.cc',
+    'third_party/boringssl-with-bazel/src/ssl/d1_srtp.cc',
+    'third_party/boringssl-with-bazel/src/ssl/dtls_method.cc',
+    'third_party/boringssl-with-bazel/src/ssl/dtls_record.cc',
+    'third_party/boringssl-with-bazel/src/ssl/handoff.cc',
+    'third_party/boringssl-with-bazel/src/ssl/handshake.cc',
+    'third_party/boringssl-with-bazel/src/ssl/handshake_client.cc',
+    'third_party/boringssl-with-bazel/src/ssl/handshake_server.cc',
+    'third_party/boringssl-with-bazel/src/ssl/s3_both.cc',
+    'third_party/boringssl-with-bazel/src/ssl/s3_lib.cc',
+    'third_party/boringssl-with-bazel/src/ssl/s3_pkt.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_aead_ctx.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_asn1.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_buffer.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_cert.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_cipher.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_file.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_key_share.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_lib.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_privkey.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_session.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_stat.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_transcript.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_versions.cc',
+    'third_party/boringssl-with-bazel/src/ssl/ssl_x509.cc',
+    'third_party/boringssl-with-bazel/src/ssl/t1_enc.cc',
+    'third_party/boringssl-with-bazel/src/ssl/t1_lib.cc',
+    'third_party/boringssl-with-bazel/src/ssl/tls13_both.cc',
+    'third_party/boringssl-with-bazel/src/ssl/tls13_client.cc',
+    'third_party/boringssl-with-bazel/src/ssl/tls13_enc.cc',
+    'third_party/boringssl-with-bazel/src/ssl/tls13_server.cc',
+    'third_party/boringssl-with-bazel/src/ssl/tls_method.cc',
+    'third_party/boringssl-with-bazel/src/ssl/tls_record.cc',
     'third_party/cares/cares/ares__close_sockets.c',
     'third_party/cares/cares/ares__get_hostent.c',
     'third_party/cares/cares/ares__read_line.c',
@@ -887,29 +887,29 @@ CORE_SOURCE_FILES = [
     'third_party/cares/cares/inet_net_pton.c',
     'third_party/cares/cares/inet_ntop.c',
     'third_party/cares/cares/windows_port.c',
-    'third_party/re2/re2/bitstate.cc', 
-    'third_party/re2/re2/compile.cc', 
-    'third_party/re2/re2/dfa.cc', 
-    'third_party/re2/re2/filtered_re2.cc', 
-    'third_party/re2/re2/mimics_pcre.cc', 
-    'third_party/re2/re2/nfa.cc', 
-    'third_party/re2/re2/onepass.cc', 
-    'third_party/re2/re2/parse.cc', 
-    'third_party/re2/re2/perl_groups.cc', 
-    'third_party/re2/re2/prefilter.cc', 
-    'third_party/re2/re2/prefilter_tree.cc', 
-    'third_party/re2/re2/prog.cc', 
-    'third_party/re2/re2/re2.cc', 
-    'third_party/re2/re2/regexp.cc', 
-    'third_party/re2/re2/set.cc', 
-    'third_party/re2/re2/simplify.cc', 
-    'third_party/re2/re2/stringpiece.cc', 
-    'third_party/re2/re2/tostring.cc', 
-    'third_party/re2/re2/unicode_casefold.cc', 
-    'third_party/re2/re2/unicode_groups.cc', 
-    'third_party/re2/util/pcre.cc', 
-    'third_party/re2/util/rune.cc', 
-    'third_party/re2/util/strutil.cc', 
+    'third_party/re2/re2/bitstate.cc',
+    'third_party/re2/re2/compile.cc',
+    'third_party/re2/re2/dfa.cc',
+    'third_party/re2/re2/filtered_re2.cc',
+    'third_party/re2/re2/mimics_pcre.cc',
+    'third_party/re2/re2/nfa.cc',
+    'third_party/re2/re2/onepass.cc',
+    'third_party/re2/re2/parse.cc',
+    'third_party/re2/re2/perl_groups.cc',
+    'third_party/re2/re2/prefilter.cc',
+    'third_party/re2/re2/prefilter_tree.cc',
+    'third_party/re2/re2/prog.cc',
+    'third_party/re2/re2/re2.cc',
+    'third_party/re2/re2/regexp.cc',
+    'third_party/re2/re2/set.cc',
+    'third_party/re2/re2/simplify.cc',
+    'third_party/re2/re2/stringpiece.cc',
+    'third_party/re2/re2/tostring.cc',
+    'third_party/re2/re2/unicode_casefold.cc',
+    'third_party/re2/re2/unicode_groups.cc',
+    'third_party/re2/util/pcre.cc',
+    'third_party/re2/util/rune.cc',
+    'third_party/re2/util/strutil.cc',
     'third_party/upb/upb/decode.c',
     'third_party/upb/upb/encode.c',
     'third_party/upb/upb/msg.c',
@@ -932,172 +932,172 @@ CORE_SOURCE_FILES = [
     'third_party/zlib/uncompr.c',
     'third_party/zlib/zutil.c',
 ]
- 
-ASM_SOURCE_FILES = { 
-    'crypto_ios_aarch64': [ 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/chacha/chacha-armv8.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/aesv8-armx64.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/armv8-mont.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/ghash-neon-armv8.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/ghashv8-armx64.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/sha1-armv8.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/sha256-armv8.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/sha512-armv8.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/vpaes-armv8.S', 
-        'third_party/boringssl-with-bazel/ios-aarch64/crypto/test/trampoline-armv8.S', 
-    ], 
-    'crypto_mac_x86_64': [ 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/chacha/chacha-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/cipher_extra/aes128gcmsiv-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/cipher_extra/chacha20_poly1305_x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/aesni-gcm-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/aesni-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/ghash-ssse3-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/ghash-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/md5-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/p256-x86_64-asm.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/p256_beeu-x86_64-asm.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/rdrand-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/rsaz-avx2.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/sha1-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/sha256-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/sha512-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/vpaes-x86_64.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/x86_64-mont.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/x86_64-mont5.S', 
-        'third_party/boringssl-with-bazel/mac-x86_64/crypto/test/trampoline-x86_64.S', 
-    ], 
-    'crypto_win_x86': [ 
-        'third_party/boringssl-with-bazel/win-x86/crypto/chacha/chacha-x86.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/aesni-x86.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/bn-586.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/co-586.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/ghash-ssse3-x86.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/ghash-x86.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/md5-586.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/sha1-586.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/sha256-586.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/sha512-586.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/vpaes-x86.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/x86-mont.asm', 
-        'third_party/boringssl-with-bazel/win-x86/crypto/test/trampoline-x86.asm', 
-    ], 
-    'crypto_linux_ppc64le': [ 
-        'third_party/boringssl-with-bazel/linux-ppc64le/crypto/fipsmodule/aesp8-ppc.S', 
-        'third_party/boringssl-with-bazel/linux-ppc64le/crypto/fipsmodule/ghashp8-ppc.S', 
-        'third_party/boringssl-with-bazel/linux-ppc64le/crypto/test/trampoline-ppc.S', 
-    ], 
-    'crypto_mac_x86': [ 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/chacha/chacha-x86.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/aesni-x86.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/bn-586.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/co-586.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/ghash-ssse3-x86.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/ghash-x86.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/md5-586.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/sha1-586.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/sha256-586.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/sha512-586.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/vpaes-x86.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/x86-mont.S', 
-        'third_party/boringssl-with-bazel/mac-x86/crypto/test/trampoline-x86.S', 
-    ], 
-    'crypto_linux_x86': [ 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/chacha/chacha-x86.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/aesni-x86.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/bn-586.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/co-586.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/ghash-ssse3-x86.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/ghash-x86.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/md5-586.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/sha1-586.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/sha256-586.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/sha512-586.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/vpaes-x86.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/x86-mont.S', 
-        'third_party/boringssl-with-bazel/linux-x86/crypto/test/trampoline-x86.S', 
-    ], 
-    'crypto_ios_arm': [ 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/chacha/chacha-armv4.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/aesv8-armx32.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/armv4-mont.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/bsaes-armv7.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/ghash-armv4.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/ghashv8-armx32.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/sha1-armv4-large.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/sha256-armv4.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/sha512-armv4.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/vpaes-armv7.S', 
-        'third_party/boringssl-with-bazel/ios-arm/crypto/test/trampoline-armv4.S', 
-    ], 
-    'crypto_linux_x86_64': [ 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/chacha/chacha-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/cipher_extra/aes128gcmsiv-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/cipher_extra/chacha20_poly1305_x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/aesni-gcm-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/aesni-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/ghash-ssse3-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/ghash-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/md5-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/p256-x86_64-asm.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/p256_beeu-x86_64-asm.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/rdrand-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/rsaz-avx2.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/sha1-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/sha256-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/sha512-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/vpaes-x86_64.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/x86_64-mont.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/x86_64-mont5.S', 
-        'third_party/boringssl-with-bazel/linux-x86_64/crypto/test/trampoline-x86_64.S', 
-        'third_party/boringssl-with-bazel/src/crypto/hrss/asm/poly_rq_mul.S', 
-    ], 
-    'crypto_win_x86_64': [ 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/chacha/chacha-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/cipher_extra/aes128gcmsiv-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/cipher_extra/chacha20_poly1305_x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/aesni-gcm-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/aesni-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/ghash-ssse3-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/ghash-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/md5-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/p256-x86_64-asm.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/p256_beeu-x86_64-asm.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/rdrand-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/rsaz-avx2.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/sha1-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/sha256-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/sha512-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/vpaes-x86_64.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/x86_64-mont.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/x86_64-mont5.asm', 
-        'third_party/boringssl-with-bazel/win-x86_64/crypto/test/trampoline-x86_64.asm', 
-    ], 
-    'crypto_linux_aarch64': [ 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/chacha/chacha-armv8.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/aesv8-armx64.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/armv8-mont.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/ghash-neon-armv8.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/ghashv8-armx64.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/sha1-armv8.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/sha256-armv8.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/sha512-armv8.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/vpaes-armv8.S', 
-        'third_party/boringssl-with-bazel/linux-aarch64/crypto/test/trampoline-armv8.S', 
-    ], 
-    'crypto_linux_arm': [ 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/chacha/chacha-armv4.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/aesv8-armx32.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/armv4-mont.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/bsaes-armv7.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/ghash-armv4.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/ghashv8-armx32.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/sha1-armv4-large.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/sha256-armv4.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/sha512-armv4.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/vpaes-armv7.S', 
-        'third_party/boringssl-with-bazel/linux-arm/crypto/test/trampoline-armv4.S', 
-        'third_party/boringssl-with-bazel/src/crypto/curve25519/asm/x25519-asm-arm.S', 
-        'third_party/boringssl-with-bazel/src/crypto/poly1305/poly1305_arm_asm.S', 
-    ], 
-} 
+
+ASM_SOURCE_FILES = {
+    'crypto_ios_aarch64': [
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/chacha/chacha-armv8.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/aesv8-armx64.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/armv8-mont.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/ghash-neon-armv8.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/ghashv8-armx64.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/sha1-armv8.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/sha256-armv8.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/sha512-armv8.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/fipsmodule/vpaes-armv8.S',
+        'third_party/boringssl-with-bazel/ios-aarch64/crypto/test/trampoline-armv8.S',
+    ],
+    'crypto_mac_x86_64': [
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/chacha/chacha-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/cipher_extra/aes128gcmsiv-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/cipher_extra/chacha20_poly1305_x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/aesni-gcm-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/aesni-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/ghash-ssse3-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/ghash-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/md5-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/p256-x86_64-asm.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/p256_beeu-x86_64-asm.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/rdrand-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/rsaz-avx2.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/sha1-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/sha256-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/sha512-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/vpaes-x86_64.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/x86_64-mont.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/fipsmodule/x86_64-mont5.S',
+        'third_party/boringssl-with-bazel/mac-x86_64/crypto/test/trampoline-x86_64.S',
+    ],
+    'crypto_win_x86': [
+        'third_party/boringssl-with-bazel/win-x86/crypto/chacha/chacha-x86.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/aesni-x86.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/bn-586.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/co-586.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/ghash-ssse3-x86.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/ghash-x86.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/md5-586.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/sha1-586.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/sha256-586.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/sha512-586.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/vpaes-x86.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/fipsmodule/x86-mont.asm',
+        'third_party/boringssl-with-bazel/win-x86/crypto/test/trampoline-x86.asm',
+    ],
+    'crypto_linux_ppc64le': [
+        'third_party/boringssl-with-bazel/linux-ppc64le/crypto/fipsmodule/aesp8-ppc.S',
+        'third_party/boringssl-with-bazel/linux-ppc64le/crypto/fipsmodule/ghashp8-ppc.S',
+        'third_party/boringssl-with-bazel/linux-ppc64le/crypto/test/trampoline-ppc.S',
+    ],
+    'crypto_mac_x86': [
+        'third_party/boringssl-with-bazel/mac-x86/crypto/chacha/chacha-x86.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/aesni-x86.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/bn-586.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/co-586.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/ghash-ssse3-x86.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/ghash-x86.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/md5-586.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/sha1-586.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/sha256-586.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/sha512-586.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/vpaes-x86.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/fipsmodule/x86-mont.S',
+        'third_party/boringssl-with-bazel/mac-x86/crypto/test/trampoline-x86.S',
+    ],
+    'crypto_linux_x86': [
+        'third_party/boringssl-with-bazel/linux-x86/crypto/chacha/chacha-x86.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/aesni-x86.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/bn-586.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/co-586.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/ghash-ssse3-x86.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/ghash-x86.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/md5-586.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/sha1-586.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/sha256-586.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/sha512-586.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/vpaes-x86.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/fipsmodule/x86-mont.S',
+        'third_party/boringssl-with-bazel/linux-x86/crypto/test/trampoline-x86.S',
+    ],
+    'crypto_ios_arm': [
+        'third_party/boringssl-with-bazel/ios-arm/crypto/chacha/chacha-armv4.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/aesv8-armx32.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/armv4-mont.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/bsaes-armv7.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/ghash-armv4.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/ghashv8-armx32.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/sha1-armv4-large.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/sha256-armv4.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/sha512-armv4.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/fipsmodule/vpaes-armv7.S',
+        'third_party/boringssl-with-bazel/ios-arm/crypto/test/trampoline-armv4.S',
+    ],
+    'crypto_linux_x86_64': [
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/chacha/chacha-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/cipher_extra/aes128gcmsiv-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/cipher_extra/chacha20_poly1305_x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/aesni-gcm-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/aesni-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/ghash-ssse3-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/ghash-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/md5-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/p256-x86_64-asm.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/p256_beeu-x86_64-asm.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/rdrand-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/rsaz-avx2.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/sha1-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/sha256-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/sha512-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/vpaes-x86_64.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/x86_64-mont.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/fipsmodule/x86_64-mont5.S',
+        'third_party/boringssl-with-bazel/linux-x86_64/crypto/test/trampoline-x86_64.S',
+        'third_party/boringssl-with-bazel/src/crypto/hrss/asm/poly_rq_mul.S',
+    ],
+    'crypto_win_x86_64': [
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/chacha/chacha-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/cipher_extra/aes128gcmsiv-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/cipher_extra/chacha20_poly1305_x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/aesni-gcm-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/aesni-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/ghash-ssse3-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/ghash-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/md5-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/p256-x86_64-asm.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/p256_beeu-x86_64-asm.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/rdrand-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/rsaz-avx2.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/sha1-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/sha256-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/sha512-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/vpaes-x86_64.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/x86_64-mont.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/fipsmodule/x86_64-mont5.asm',
+        'third_party/boringssl-with-bazel/win-x86_64/crypto/test/trampoline-x86_64.asm',
+    ],
+    'crypto_linux_aarch64': [
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/chacha/chacha-armv8.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/aesv8-armx64.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/armv8-mont.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/ghash-neon-armv8.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/ghashv8-armx64.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/sha1-armv8.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/sha256-armv8.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/sha512-armv8.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/fipsmodule/vpaes-armv8.S',
+        'third_party/boringssl-with-bazel/linux-aarch64/crypto/test/trampoline-armv8.S',
+    ],
+    'crypto_linux_arm': [
+        'third_party/boringssl-with-bazel/linux-arm/crypto/chacha/chacha-armv4.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/aesv8-armx32.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/armv4-mont.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/bsaes-armv7.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/ghash-armv4.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/ghashv8-armx32.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/sha1-armv4-large.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/sha256-armv4.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/sha512-armv4.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/fipsmodule/vpaes-armv7.S',
+        'third_party/boringssl-with-bazel/linux-arm/crypto/test/trampoline-armv4.S',
+        'third_party/boringssl-with-bazel/src/crypto/curve25519/asm/x25519-asm-arm.S',
+        'third_party/boringssl-with-bazel/src/crypto/poly1305/poly1305_arm_asm.S',
+    ],
+}
diff --git a/contrib/libs/grpc/src/python/grpcio/grpc_version.py b/contrib/libs/grpc/src/python/grpcio/grpc_version.py
index aab68348ef..9237f14e2f 100644
--- a/contrib/libs/grpc/src/python/grpcio/grpc_version.py
+++ b/contrib/libs/grpc/src/python/grpcio/grpc_version.py
@@ -14,4 +14,4 @@
 
 # AUTO-GENERATED FROM `$REPO_ROOT/templates/src/python/grpcio/grpc_version.py.template`!!!
 
-VERSION = '1.33.2' 
+VERSION = '1.33.2'
diff --git a/contrib/libs/grpc/src/python/grpcio/support.py b/contrib/libs/grpc/src/python/grpcio/support.py
index 725b5eb76f..217f3cb9ed 100644
--- a/contrib/libs/grpc/src/python/grpcio/support.py
+++ b/contrib/libs/grpc/src/python/grpcio/support.py
@@ -28,25 +28,25 @@ int main(int argc, char **argv) { return 0; }
 """
 C_PYTHON_DEV_ERROR_MESSAGE = """
 Could not find <Python.h>. This could mean the following:
-  * You're on Ubuntu and haven't run `apt-get install <PY_REPR>-dev`. 
-  * You're on RHEL/Fedora and haven't run `yum install <PY_REPR>-devel` or 
-    `dnf install <PY_REPR>-devel` (make sure you also have redhat-rpm-config 
+  * You're on Ubuntu and haven't run `apt-get install <PY_REPR>-dev`.
+  * You're on RHEL/Fedora and haven't run `yum install <PY_REPR>-devel` or
+    `dnf install <PY_REPR>-devel` (make sure you also have redhat-rpm-config
     installed)
   * You're on Mac OS X and the usual Python framework was somehow corrupted
     (check your environment variables or try re-installing?)
   * You're on Windows and your Python installation was somehow corrupted
     (check your environment variables or try re-installing?)
 """
-if sys.version_info[0] == 2: 
-    PYTHON_REPRESENTATION = 'python' 
-elif sys.version_info[0] == 3: 
-    PYTHON_REPRESENTATION = 'python3' 
-else: 
-    raise NotImplementedError('Unsupported Python version: %s' % sys.version) 
+if sys.version_info[0] == 2:
+    PYTHON_REPRESENTATION = 'python'
+elif sys.version_info[0] == 3:
+    PYTHON_REPRESENTATION = 'python3'
+else:
+    raise NotImplementedError('Unsupported Python version: %s' % sys.version)
 
 C_CHECKS = {
-    C_PYTHON_DEV: 
-        C_PYTHON_DEV_ERROR_MESSAGE.replace('<PY_REPR>', PYTHON_REPRESENTATION), 
+    C_PYTHON_DEV:
+        C_PYTHON_DEV_ERROR_MESSAGE.replace('<PY_REPR>', PYTHON_REPRESENTATION),
 }
 
 
@@ -67,8 +67,8 @@ def _expect_compile(compiler, source_string, error_message):
     if _compile(compiler, source_string) is not None:
         sys.stderr.write(error_message)
         raise commands.CommandError(
-            "Diagnostics found a compilation environment issue:\n{}".format( 
-                error_message)) 
+            "Diagnostics found a compilation environment issue:\n{}".format(
+                error_message))
 
 
 def diagnose_compile_error(build_ext, error):
diff --git a/contrib/libs/grpc/src/python/grpcio/ya.make b/contrib/libs/grpc/src/python/grpcio/ya.make
index 08008762b0..5cdb0230c4 100644
--- a/contrib/libs/grpc/src/python/grpcio/ya.make
+++ b/contrib/libs/grpc/src/python/grpcio/ya.make
@@ -2,8 +2,8 @@ PY23_LIBRARY()
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
- 
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
+
 OWNER(
     akastornov
     g:contrib
@@ -23,7 +23,7 @@ IF (PYTHON2)
 ENDIF()
 
 ADDINCL(
-    ${ARCADIA_BUILD_ROOT}/contrib/libs/grpc 
+    ${ARCADIA_BUILD_ROOT}/contrib/libs/grpc
     contrib/libs/grpc
     contrib/libs/grpc/include
 )
@@ -50,7 +50,7 @@ PY_SRCS(
     grpc/_grpcio_metadata.py
     grpc/_interceptor.py
     grpc/_plugin_wrapping.py
-    grpc/_runtime_protos.py 
+    grpc/_runtime_protos.py
     grpc/_server.py
     grpc/_utilities.py
     grpc/beta/__init__.py
@@ -86,18 +86,18 @@ PY_SRCS(
 IF (PYTHON3)
     PY_SRCS(
         TOP_LEVEL
-        grpc/_simple_stubs.py 
-        grpc/aio/_base_call.py 
-        grpc/aio/_base_channel.py 
-        grpc/aio/_base_server.py 
-        grpc/aio/_call.py 
-        grpc/aio/_channel.py 
-        grpc/aio/__init__.py 
-        grpc/aio/_interceptor.py 
-        grpc/aio/_metadata.py 
-        grpc/aio/_server.py 
-        grpc/aio/_typing.py 
-        grpc/aio/_utils.py 
+        grpc/_simple_stubs.py
+        grpc/aio/_base_call.py
+        grpc/aio/_base_channel.py
+        grpc/aio/_base_server.py
+        grpc/aio/_call.py
+        grpc/aio/_channel.py
+        grpc/aio/__init__.py
+        grpc/aio/_interceptor.py
+        grpc/aio/_metadata.py
+        grpc/aio/_server.py
+        grpc/aio/_typing.py
+        grpc/aio/_utils.py
         grpc/experimental/aio/__init__.py
     )
 ENDIF()