chore: Update gapic-generator-python to v1.8.5 (#194)

* feat: enable "rest" transport in Python for services supporting numeric enums PiperOrigin-RevId: 508143576 Source-Link: googleapis/googleapis@7a702a9 Source-Link: https://github.com/googleapis/googleapis-gen/commit/6ad1279c0e7aa787ac6b66c9fd4a210692edffcd Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiNmFkMTI3OWMwZTdhYTc4N2FjNmI2NmM5ZmQ0YTIxMDY5MmVkZmZjZCJ9 * 🦉 Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md * chore: Update gapic-generator-python to v1.8.5 PiperOrigin-RevId: 511892190 Source-Link: googleapis/googleapis@a45d9c0 Source-Link: https://github.com/googleapis/googleapis-gen/commit/1907294b1d8365ea24f8c5f2e059a64124c4ed3b Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiMTkwNzI5NGIxZDgzNjVlYTI0ZjhjNWYyZTA1OWE2NDEyNGM0ZWQzYiJ9 * 🦉 Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md --------- Co-authored-by: Owl Bot <gcf-owl-bot[bot]@users.noreply.github.com> Co-authored-by: Victor Chudnovsky <vchudnov@google.com>

Author: gcf-owl-bot[bot]

google/cloud/servicecontrol_v1/gapic_metadata.json

@@ -26,6 +26,16 @@
  ]
  }
  }
+ },
+ "rest": {
+ "libraryClient": "QuotaControllerClient",
+ "rpcs": {
+ "AllocateQuota": {
+ "methods": [
+ "allocate_quota"
+ ]
+ }
+ }
  }
  }
  },
@@ -60,6 +70,21 @@
  ]
  }
  }
+ },
+ "rest": {
+ "libraryClient": "ServiceControllerClient",
+ "rpcs": {
+ "Check": {
+ "methods": [
+ "check"
+ ]
+ },
+ "Report": {
+ "methods": [
+ "report"
+ ]
+ }
+ }
  }
  }
  }

google/cloud/servicecontrol_v1/services/quota_controller/client.py

@@ -51,6 +51,7 @@
 from .transports.base import DEFAULT_CLIENT_INFO, QuotaControllerTransport
 from .transports.grpc import QuotaControllerGrpcTransport
 from .transports.grpc_asyncio import QuotaControllerGrpcAsyncIOTransport
+from .transports.rest import QuotaControllerRestTransport
 
 
 class QuotaControllerClientMeta(type):
@@ -66,6 +67,7 @@ class QuotaControllerClientMeta(type):
  ) # type: Dict[str, Type[QuotaControllerTransport]]
  _transport_registry["grpc"] = QuotaControllerGrpcTransport
  _transport_registry["grpc_asyncio"] = QuotaControllerGrpcAsyncIOTransport
+ _transport_registry["rest"] = QuotaControllerRestTransport
 
  def get_transport_class(
  cls,

google/cloud/servicecontrol_v1/services/quota_controller/transports/__init__.py

@@ -19,14 +19,18 @@
 from .base import QuotaControllerTransport
 from .grpc import QuotaControllerGrpcTransport
 from .grpc_asyncio import QuotaControllerGrpcAsyncIOTransport
+from .rest import QuotaControllerRestInterceptor, QuotaControllerRestTransport
 
 # Compile a registry of transports.
 _transport_registry = OrderedDict() # type: Dict[str, Type[QuotaControllerTransport]]
 _transport_registry["grpc"] = QuotaControllerGrpcTransport
 _transport_registry["grpc_asyncio"] = QuotaControllerGrpcAsyncIOTransport
+_transport_registry["rest"] = QuotaControllerRestTransport
 
 __all__ = (
  "QuotaControllerTransport",
  "QuotaControllerGrpcTransport",
  "QuotaControllerGrpcAsyncIOTransport",
+ "QuotaControllerRestTransport",
+ "QuotaControllerRestInterceptor",
 )

google/cloud/servicecontrol_v1/services/quota_controller/transports/rest.py

@@ -0,0 +1,309 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# 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 dataclasses
+import json # type: ignore
+import re
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+import warnings
+
+from google.api_core import gapic_v1, path_template, rest_helpers, rest_streaming
+from google.api_core import exceptions as core_exceptions
+from google.api_core import retry as retries
+from google.auth import credentials as ga_credentials # type: ignore
+from google.auth.transport.grpc import SslCredentials # type: ignore
+from google.auth.transport.requests import AuthorizedSession # type: ignore
+from google.protobuf import json_format
+import grpc # type: ignore
+from requests import __version__ as requests_version
+
+try:
+ OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault]
+except AttributeError: # pragma: NO COVER
+ OptionalRetry = Union[retries.Retry, object] # type: ignore
+
+
+from google.cloud.servicecontrol_v1.types import quota_controller
+
+from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO
+from .base import QuotaControllerTransport
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+ gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
+ grpc_version=None,
+ rest_version=requests_version,
+)
+
+
+class QuotaControllerRestInterceptor:
+ """Interceptor for QuotaController.
+
+ Interceptors are used to manipulate requests, request metadata, and responses
+ in arbitrary ways.
+ Example use cases include:
+ * Logging
+ * Verifying requests according to service or custom semantics
+ * Stripping extraneous information from responses
+
+ These use cases and more can be enabled by injecting an
+ instance of a custom subclass when constructing the QuotaControllerRestTransport.
+
+ .. code-block:: python
+ class MyCustomQuotaControllerInterceptor(QuotaControllerRestInterceptor):
+ def pre_allocate_quota(self, request, metadata):
+ logging.log(f"Received request: {request}")
+ return request, metadata
+
+ def post_allocate_quota(self, response):
+ logging.log(f"Received response: {response}")
+ return response
+
+ transport = QuotaControllerRestTransport(interceptor=MyCustomQuotaControllerInterceptor())
+ client = QuotaControllerClient(transport=transport)
+
+
+ """
+
+ def pre_allocate_quota(
+ self,
+ request: quota_controller.AllocateQuotaRequest,
+ metadata: Sequence[Tuple[str, str]],
+ ) -> Tuple[quota_controller.AllocateQuotaRequest, Sequence[Tuple[str, str]]]:
+ """Pre-rpc interceptor for allocate_quota
+
+ Override in a subclass to manipulate the request or metadata
+ before they are sent to the QuotaController server.
+ """
+ return request, metadata
+
+ def post_allocate_quota(
+ self, response: quota_controller.AllocateQuotaResponse
+ ) -> quota_controller.AllocateQuotaResponse:
+ """Post-rpc interceptor for allocate_quota
+
+ Override in a subclass to manipulate the response
+ after it is returned by the QuotaController server but before
+ it is returned to user code.
+ """
+ return response
+
+
+@dataclasses.dataclass
+class QuotaControllerRestStub:
+ _session: AuthorizedSession
+ _host: str
+ _interceptor: QuotaControllerRestInterceptor
+
+
+class QuotaControllerRestTransport(QuotaControllerTransport):
+ """REST backend transport for QuotaController.
+
+ `Google Quota Control API </service-control/overview>`__
+
+ Allows clients to allocate and release quota against a `managed
+ service <https://cloud.google.com/service-management/reference/rpc/google.api/servicemanagement.v1#google.api.servicemanagement.v1.ManagedService>`__.
+
+ This class defines the same methods as the primary client, so the
+ primary client can load the underlying transport implementation
+ and call it.
+
+ It sends JSON representations of protocol buffers over HTTP/1.1
+
+ """
+
+ def __init__(
+ self,
+ *,
+ host: str = "servicecontrol.googleapis.com",
+ credentials: Optional[ga_credentials.Credentials] = None,
+ credentials_file: Optional[str] = None,
+ scopes: Optional[Sequence[str]] = None,
+ client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+ quota_project_id: Optional[str] = None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ always_use_jwt_access: Optional[bool] = False,
+ url_scheme: str = "https",
+ interceptor: Optional[QuotaControllerRestInterceptor] = None,
+ api_audience: Optional[str] = None,
+ ) -> None:
+ """Instantiate the transport.
+
+ Args:
+ host (Optional[str]):
+ 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.
+
+ credentials_file (Optional[str]): A file with credentials that can
+ be loaded with :func:`google.auth.load_credentials_from_file`.
+ This argument is ignored if ``channel`` is provided.
+ scopes (Optional(Sequence[str])): A list of scopes. This argument is
+ ignored if ``channel`` is provided.
+ client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
+ certificate to configure mutual TLS HTTP channel. It is ignored
+ if ``channel`` is provided.
+ quota_project_id (Optional[str]): An optional project to use for billing
+ and quota.
+ client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+ The client info used to send a user-agent string along with
+ API requests. If ``None``, then default info will be used.
+ Generally, you only need to set this if you are developing
+ your own client library.
+ always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+ be used for service account credentials.
+ url_scheme: the protocol scheme for the API endpoint. Normally
+ "https", but for testing or local servers,
+ "http" can be specified.
+ """
+ # Run the base constructor
+ # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
+ # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
+ # credentials object
+ maybe_url_match = re.match("^(?P<scheme>http(?:s)?://)?(?P<host>.*)$", host)
+ if maybe_url_match is None:
+ raise ValueError(
+ f"Unexpected hostname structure: {host}"
+ ) # pragma: NO COVER
+
+ url_match_items = maybe_url_match.groupdict()
+
+ host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
+
+ super().__init__(
+ host=host,
+ credentials=credentials,
+ client_info=client_info,
+ always_use_jwt_access=always_use_jwt_access,
+ api_audience=api_audience,
+ )
+ self._session = AuthorizedSession(
+ self._credentials, default_host=self.DEFAULT_HOST
+ )
+ if client_cert_source_for_mtls:
+ self._session.configure_mtls_channel(client_cert_source_for_mtls)
+ self._interceptor = interceptor or QuotaControllerRestInterceptor()
+ self._prep_wrapped_messages(client_info)
+
+ class _AllocateQuota(QuotaControllerRestStub):
+ def __hash__(self):
+ return hash("AllocateQuota")
+
+ def __call__(
+ self,
+ request: quota_controller.AllocateQuotaRequest,
+ *,
+ retry: OptionalRetry = gapic_v1.method.DEFAULT,
+ timeout: Optional[float] = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> quota_controller.AllocateQuotaResponse:
+ r"""Call the allocate quota method over HTTP.
+
+ Args:
+ request (~.quota_controller.AllocateQuotaRequest):
+ The request object. Request message for the AllocateQuota
+ method.
+
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ ~.quota_controller.AllocateQuotaResponse:
+ Response message for the
+ AllocateQuota method.
+
+ """
+
+ http_options: List[Dict[str, str]] = [
+ {
+ "method": "post",
+ "uri": "/v1/services/{service_name}:allocateQuota",
+ "body": "*",
+ },
+ ]
+ request, metadata = self._interceptor.pre_allocate_quota(request, metadata)
+ pb_request = quota_controller.AllocateQuotaRequest.pb(request)
+ transcoded_request = path_template.transcode(http_options, pb_request)
+
+ # Jsonify the request body
+
+ body = json_format.MessageToJson(
+ transcoded_request["body"],
+ including_default_value_fields=False,
+ use_integers_for_enums=True,
+ )
+ uri = transcoded_request["uri"]
+ method = transcoded_request["method"]
+
+ # Jsonify the query params
+ query_params = json.loads(
+ json_format.MessageToJson(
+ transcoded_request["query_params"],
+ including_default_value_fields=False,
+ use_integers_for_enums=True,
+ )
+ )
+
+ query_params["$alt"] = "json;enum-encoding=int"
+
+ # Send the request
+ headers = dict(metadata)
+ headers["Content-Type"] = "application/json"
+ response = getattr(self._session, method)(
+ "{host}{uri}".format(host=self._host, uri=uri),
+ timeout=timeout,
+ headers=headers,
+ params=rest_helpers.flatten_query_params(query_params, strict=True),
+ data=body,
+ )
+
+ # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+ # subclass.
+ if response.status_code >= 400:
+ raise core_exceptions.from_http_response(response)
+
+ # Return the response
+ resp = quota_controller.AllocateQuotaResponse()
+ pb_resp = quota_controller.AllocateQuotaResponse.pb(resp)
+
+ json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+ resp = self._interceptor.post_allocate_quota(resp)
+ return resp
+
+ @property
+ def allocate_quota(
+ self,
+ ) -> Callable[
+ [quota_controller.AllocateQuotaRequest], quota_controller.AllocateQuotaResponse
+ ]:
+ # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+ # In C++ this would require a dynamic_cast
+ return self._AllocateQuota(self._session, self._host, self._interceptor) # type: ignore
+
+ @property
+ def kind(self) -> str:
+ return "rest"
+
+ def close(self):
+ self._session.close()
+
+
+__all__ = ("QuotaControllerRestTransport",)

google/cloud/servicecontrol_v1/services/service_controller/client.py

@@ -51,6 +51,7 @@
 from .transports.base import DEFAULT_CLIENT_INFO, ServiceControllerTransport
 from .transports.grpc import ServiceControllerGrpcTransport
 from .transports.grpc_asyncio import ServiceControllerGrpcAsyncIOTransport
+from .transports.rest import ServiceControllerRestTransport
 
 
 class ServiceControllerClientMeta(type):
@@ -66,6 +67,7 @@ class ServiceControllerClientMeta(type):
  ) # type: Dict[str, Type[ServiceControllerTransport]]
  _transport_registry["grpc"] = ServiceControllerGrpcTransport
  _transport_registry["grpc_asyncio"] = ServiceControllerGrpcAsyncIOTransport
+ _transport_registry["rest"] = ServiceControllerRestTransport
 
  def get_transport_class(
  cls,