Add a common class for gRPC transport and gRPC AsyncIO transport

Author: lidizheng

gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/base.py.j2

@@ -17,7 +17,7 @@ from google.auth import credentials  # type: ignore
 {% endfor -%}
 {% endfilter %}
 
-class {{ service.name }}Transport(metaclass=abc.ABCMeta):
+class {{ service.name }}Transport(abc.ABC):
     """Abstract transport class for {{ service.name }}."""
 
     AUTH_SCOPES = (

gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/grpc.py.j2

@@ -1,7 +1,7 @@
 {% extends '_base.py.j2' %}
 
 {% block content %}
-from typing import Callable, Dict, Tuple
+from typing import Callable, Dict, Sequence, Tuple
 
 from google.api_core import grpc_helpers   # type: ignore
 {%- if service.has_lro %}
@@ -19,10 +19,10 @@ import grpc  # type: ignore
 {{ method.output.ident.python_import }}
 {% endfor -%}
 {% endfilter %}
-from .base import {{ service.name }}Transport
+from .grpc_base import {{ service.name }}GrpcBaseTransport
 
 
-class {{ service.name }}GrpcTransport({{ service.name }}Transport):
+class {{ service.name }}GrpcTransport({{ service.name }}GrpcBaseTransport[grpc.Channel]):
     """gRPC backend transport for {{ service.name }}.
 
     {{ service.meta.doc|rst(width=72, indent=4) }}
@@ -34,75 +34,12 @@ class {{ service.name }}GrpcTransport({{ service.name }}Transport):
     It sends protocol buffers over the wire using gRPC (which is built on
     top of HTTP/2); the ``grpcio`` package must be installed.
     """
-    def __init__(self, *,
-            host: str{% if service.host %} = '{{ service.host }}'{% endif %},
-            credentials: credentials.Credentials = None,
-            channel: grpc.Channel = None,
-            api_mtls_endpoint: str = None,
-            client_cert_source: Callable[[], Tuple[bytes, bytes]] = None) -> None:
-        """Instantiate the transport.
-
-        Args:
-            host ({% if service.host %}Optional[str]{% else %}str{% endif %}):
-                {{- ' ' }}The hostname to connect to.
-            credentials (Optional[google.auth.credentials.Credentials]): The
-                authorization credentials to attach to requests. These
-                credentials identify the application to the service; if none
-                are specified, the client will attempt to ascertain the
-                credentials from the environment.
-                This argument is ignored if ``channel`` is provided.
-            channel (Optional[grpc.Channel]): A ``Channel`` instance through
-                which to make calls.
-            api_mtls_endpoint (Optional[str]): The mutual TLS endpoint. If
-                provided, it overrides the ``host`` argument and tries to create
-                a mutual TLS channel with client SSL credentials from
-                ``client_cert_source`` or applicatin default SSL credentials.
-            client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]): A
-                callback to provide client SSL certificate bytes and private key
-                bytes, both in PEM format. It is ignored if ``api_mtls_endpoint``
-                is None.
-
-        Raises:
-          google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
-              creation failed for any reason.
-        """
-        if channel:
-            # Sanity check: Ensure that channel and credentials are not both
-            # provided.
-            credentials = False
-
-            # If a channel was explicitly provided, set it.
-            self._grpc_channel = channel
-        elif api_mtls_endpoint:
-            host = api_mtls_endpoint if ":" in api_mtls_endpoint else api_mtls_endpoint + ":443"
-
-            # Create SSL credentials with client_cert_source or application
-            # default SSL credentials.
-            if client_cert_source:
-                cert, key = client_cert_source()
-                ssl_credentials = grpc.ssl_channel_credentials(
-                    certificate_chain=cert, private_key=key
-                )
-            else:
-                ssl_credentials = SslCredentials().ssl_credentials
-
-            # create a new channel. The provided one is ignored.
-            self._grpc_channel = grpc_helpers.create_channel(
-                host,
-                credentials=credentials,
-                ssl_credentials=ssl_credentials,
-                scopes=self.AUTH_SCOPES,
-            )
-
-        # Run the base constructor.
-        super().__init__(host=host, credentials=credentials)
-        self._stubs = {}  # type: Dict[str, Callable]
-
 
     @classmethod
     def create_channel(cls,
                        host: str{% if service.host %} = '{{ service.host }}'{% endif %},
                        credentials: credentials.Credentials = None,
+                       scopes: Sequence[str] = None,
                        **kwargs) -> grpc.Channel:
         """Create and return a gRPC channel object.
         Args:
@@ -112,35 +49,23 @@ class {{ service.name }}GrpcTransport({{ service.name }}Transport):
                 credentials identify this application to the service. If
                 none are specified, the client will attempt to ascertain
                 the credentials from the environment.
+            scopes (Sequence[str]): A optional list of scopes needed for this
+                service. These are only used when credentials are not specified and
+                are passed to :func:`google.auth.default`.
             kwargs (Optional[dict]): Keyword arguments, which are passed to the
                 channel creation.
         Returns:
             grpc.Channel: A gRPC channel object.
         """
+        if scopes is None:
+            scopes = cls.AUTH_SCOPES
         return grpc_helpers.create_channel(
             host,
             credentials=credentials,
-            scopes=cls.AUTH_SCOPES,
+            scopes=scopes,
             **kwargs
         )
 
-    @property
-    def grpc_channel(self) -> grpc.Channel:
-        """Create the channel designed to connect to this service.
-
-        This property caches on the instance; repeated calls return
-        the same channel.
-        """
-        # Sanity check: Only create a new channel if we do not already
-        # have one.
-        if not hasattr(self, '_grpc_channel'):
-            self._grpc_channel = self.create_channel(
-                self._host,
-                credentials=self._credentials,
-            )
-
-        # Return the channel from cache.
-        return self._grpc_channel
     {%- if service.has_lro %}
 
     @property
@@ -178,17 +103,7 @@ class {{ service.name }}GrpcTransport({{ service.name }}Transport):
                 A function that, when called, will call the underlying RPC
                 on the server.
         """
-        # Generate a "stub function" on-the-fly which will actually make
-        # the request.
-        # gRPC handles serialization and deserialization, so we just need
-        # to pass in the functions for each.
-        if '{{ method.name|snake_case }}' not in self._stubs:
-            self._stubs['{{ method.name|snake_case }}'] = self.grpc_channel.{{ method.grpc_stub_type }}(
-                '/{{ '.'.join(method.meta.address.package) }}.{{ service.name }}/{{ method.name }}',
-                request_serializer={{ method.input.ident }}.{% if method.input.ident.python_import.module.endswith('_pb2') %}SerializeToString{% else %}serialize{% endif %},
-                response_deserializer={{ method.output.ident }}.{% if method.output.ident.python_import.module.endswith('_pb2') %}FromString{% else %}deserialize{% endif %},
-            )
-        return self._stubs['{{ method.name|snake_case }}']
+        return super().{{ method.name|snake_case }}
     {%- endfor %}
 
 

gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/grpc_asyncio.py.j2

@@ -1,15 +1,14 @@
 {% extends '_base.py.j2' %}
 
 {% block content %}
-from typing import Awaitable, Callable, Dict
+from typing import Awaitable, Callable, Dict, Sequence, Tuple
 
 from google.api_core import grpc_helpers_async   # type: ignore
 {%- if service.has_lro %}
 from google.api_core import operations_v1  # type: ignore
 {%- endif %}
 from google.auth import credentials        # type: ignore
 
-import grpc  # type: ignore
 from grpc.experimental import aio  # type: ignore
 
 {% filter sort_lines -%}
@@ -18,10 +17,10 @@ from grpc.experimental import aio  # type: ignore
 {{ method.output.ident.python_import }}
 {% endfor -%}
 {% endfilter %}
-from .base import {{ service.name }}Transport
+from .grpc_base import {{ service.name }}GrpcBaseTransport
 
 
-class {{ service.name }}GrpcAsyncIOTransport({{ service.name }}Transport):
+class {{ service.grpc_asyncio_transport_name }}({{ service.name }}GrpcBaseTransport[aio.Channel]):
     """gRPC AsyncIO backend transport for {{ service.name }}.
 
     {{ service.meta.doc|rst(width=72, indent=4) }}
@@ -33,44 +32,12 @@ class {{ service.name }}GrpcAsyncIOTransport({{ service.name }}Transport):
     It sends protocol buffers over the wire using gRPC (which is built on
     top of HTTP/2); the ``grpcio`` package must be installed.
     """
-    _stubs: Dict[str, Callable]
-    _grpc_channel: aio.Channel
-
-    def __init__(self, *,
-            host: str{% if service.host %} = '{{ service.host }}'{% endif %},
-            credentials: credentials.Credentials = None,
-            channel: aio.Channel = None) -> None:
-        """Instantiate the transport.
-
-        Args:
-            host ({% if service.host %}Optional[str]{% else %}str{% endif %}):
-                {{- ' ' }}The hostname to connect to.
-            credentials (Optional[google.auth.credentials.Credentials]): The
-                authorization credentials to attach to requests. These
-                credentials identify the application to the service; if none
-                are specified, the client will attempt to ascertain the
-                credentials from the environment.
-                This argument is ignored if ``channel`` is provided.
-            channel (Optional[aio.Channel]): A ``Channel`` instance through
-                which to make calls.
-        """
-        # Sanity check: Ensure that channel and credentials are not both
-        # provided.
-        if channel:
-            credentials = False
-
-        # Run the base constructor.
-        super().__init__(host=host, credentials=credentials)
-        self._stubs = {}  # type: Dict[str, Callable]
-
-        # If a channel was explicitly provided, set it.
-        if channel:
-            self._grpc_channel = channel
 
     @classmethod
     def create_channel(cls,
                        host: str{% if service.host %} = '{{ service.host }}'{% endif %},
                        credentials: credentials.Credentials = None,
+                       scopes: Sequence[str] = None,
                        **kwargs) -> aio.Channel:
         """Create and return a gRPC AsyncIO channel object.
         Args:
@@ -80,35 +47,23 @@ class {{ service.name }}GrpcAsyncIOTransport({{ service.name }}Transport):
                 credentials identify this application to the service. If
                 none are specified, the client will attempt to ascertain
                 the credentials from the environment.
+            scopes (Sequence[str]): A optional list of scopes needed for this
+                service. These are only used when credentials are not specified and
+                are passed to :func:`google.auth.default`.
             kwargs (Optional[dict]): Keyword arguments, which are passed to the
                 channel creation.
         Returns:
             aio.Channel: A gRPC AsyncIO channel object.
         """
+        if scopes is None:
+            scopes = cls.AUTH_SCOPES
         return grpc_helpers_async.create_channel(
             host,
             credentials=credentials,
-            scopes=cls.AUTH_SCOPES,
+            scopes=scopes,
             **kwargs
         )
 
-    @property
-    def grpc_channel(self) -> aio.Channel:
-        """Create the channel designed to connect to this service.
-
-        This property caches on the instance; repeated calls return
-        the same channel.
-        """
-        # Sanity check: Only create a new channel if we do not already
-        # have one.
-        if not hasattr(self, '_grpc_channel'):
-            self._grpc_channel = self.create_channel(
-                self._host,
-                credentials=self._credentials,
-            )
-
-        # Return the channel from cache.
-        return self._grpc_channel
     {%- if service.has_lro %}
 
     @property
@@ -142,21 +97,11 @@ class {{ service.name }}GrpcAsyncIOTransport({{ service.name }}Transport):
 
         Returns:
             Callable[[~.{{ method.input.name }}],
-                    ~.{{ method.output.name }}]:
+                    Awaitable[~.{{ method.output.name }}]]:
                 A function that, when called, will call the underlying RPC
                 on the server.
         """
-        # Generate a "stub function" on-the-fly which will actually make
-        # the request.
-        # gRPC handles serialization and deserialization, so we just need
-        # to pass in the functions for each.
-        if '{{ method.name|snake_case }}' not in self._stubs:
-            self._stubs['{{ method.name|snake_case }}'] = self.grpc_channel.{{ method.grpc_stub_type }}(
-                '/{{ '.'.join(method.meta.address.package) }}.{{ service.name }}/{{ method.name }}',
-                request_serializer={{ method.input.ident }}.{% if method.input.ident.python_import.module.endswith('_pb2') %}SerializeToString{% else %}serialize{% endif %},
-                response_deserializer={{ method.output.ident }}.{% if method.output.ident.python_import.module.endswith('_pb2') %}FromString{% else %}deserialize{% endif %},
-            )
-        return self._stubs['{{ method.name|snake_case }}']
+        return super().{{ method.name|snake_case }}
     {%- endfor %}