diff --git a/packages/gapic-generator/gapic/generator/generator.py b/packages/gapic-generator/gapic/generator/generator.py index 9fe56aa9de1d..c1932abbe426 100644 --- a/packages/gapic-generator/gapic/generator/generator.py +++ b/packages/gapic-generator/gapic/generator/generator.py @@ -120,7 +120,7 @@ def get_response(self, api_schema: api.API, opts: Options) -> CodeGeneratorRespo for template_name in client_templates: # Quick check: Skip "private" templates. filename = template_name.split("/")[-1] - if filename.startswith("_") and filename != "__init__.py.j2": + if filename.startswith("_") and filename not in ("__init__.py.j2", "_compat.py.j2"): continue # Append to the output files dictionary. diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/_compat.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/_compat.py.j2 new file mode 100644 index 000000000000..894ed4db0fb4 --- /dev/null +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/_compat.py.j2 @@ -0,0 +1,303 @@ +# {% include '_license.j2' %} + +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json + diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 index 755e4530e7ba..584b77e580d7 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 @@ -198,22 +198,23 @@ def _get_http_options(): service: The service. is_async (bool): Used to determine the code path i.e. whether for sync or async call. is_request_message_proto_plus_type (bool): Used to determine whether the request message is a proto-plus type. #} -{% macro rest_call_method_common(body_spec, method_name, service, is_async=False, is_request_message_proto_plus_type=False) %} +{% macro rest_call_method_common(body_spec, method_name, service, is_async=False, is_request_message_proto_plus_type=False, rest_numeric_enums=False) %} {% set service_name = service.name %} {% set await_prefix = "await " if is_async else "" %} {% set async_class_prefix = "Async" if is_async else "" %} http_options = _Base{{ service_name }}RestTransport._Base{{method_name}}._get_http_options() - {# TODO(https://github.com/googleapis/gapic-generator-python/issues/2274): Add debug log before intercepting a request #} request, metadata = {{ await_prefix }}self._interceptor.pre_{{ method_name|snake_case }}(request, metadata) - transcoded_request = _Base{{ service_name }}RestTransport._Base{{method_name}}._get_transcoded_request(http_options, request) - - {% if body_spec %} - body = _Base{{ service_name }}RestTransport._Base{{method_name}}._get_request_body_json(transcoded_request) - {% endif %}{# body_spec #} - - # Jsonify the query params - query_params = _Base{{ service_name }}RestTransport._Base{{method_name}}._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _Base{{ service_name }}RestTransport._Base{{method_name}}, + "_Base{{method_name}}__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums={{ rest_numeric_enums }}, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/_rest_mixins_base.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/_rest_mixins_base.py.j2 index 16cc77ea937c..042de855681e 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/_rest_mixins_base.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/_rest_mixins_base.py.j2 @@ -20,32 +20,11 @@ {% for name, sig in api.mixin_api_signatures.items() %} class _Base{{ name }}: + """Base class for {{ name }} REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") {{ shared_macros.http_options_method(api.mixin_http_options["{}".format(name)])|indent(8)}} - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - {% set body_spec = api.mixin_http_options["{}".format(name)][0].body %} - {%- if body_spec %} - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - - {%- endif %} {# body_spec #} - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - {% endfor %} {% endif %} {# rest in opts.transport #} diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 index 49c1374053b5..a3e08a447d06 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 @@ -10,7 +10,8 @@ from google.auth.transport.requests import AuthorizedSession # type: ignore from google.auth import credentials as ga_credentials # type: ignore from google.api_core import exceptions as core_exceptions from google.api_core import retry as retries -from google.api_core import rest_helpers +{% set package_path = api.naming.module_namespace|join('.') + "." + api.naming.versioned_module_name %} +from {{package_path}} import _compat as rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 import google.protobuf @@ -245,7 +246,7 @@ class {{service.name}}RestTransport(_Base{{ service.name }}RestTransport): {% endif %} """ - {{ shared_macros.rest_call_method_common(body_spec, method.name, service, False, method.input.ident.is_proto_plus_type)|indent(8) }} + {{ shared_macros.rest_call_method_common(body_spec, method.name, service, False, method.input.ident.is_proto_plus_type, opts.rest_numeric_enums)|indent(8) }} {% if not method.void %} # Return the response diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 index 80980572c30a..83c8cd28b986 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 @@ -32,7 +32,8 @@ from google.iam.v1 import policy_pb2 # type: ignore from google.cloud.location import locations_pb2 # type: ignore {% endif %} from google.api_core import retry_async as retries -from google.api_core import rest_helpers +{% set package_path = api.naming.module_namespace|join('.') + "." + api.naming.versioned_module_name %} +from {{package_path}} import _compat as rest_helpers from google.api_core import rest_streaming_async # type: ignore import google.protobuf @@ -203,7 +204,7 @@ class Async{{service.name}}RestTransport(_Base{{ service.name }}RestTransport): {% endif %} """ - {{ shared_macros.rest_call_method_common(body_spec, method.name, service, True, method.input.ident.is_proto_plus_type)|indent(8) }} + {{ shared_macros.rest_call_method_common(body_spec, method.name, service, True, method.input.ident.is_proto_plus_type, opts.rest_numeric_enums)|indent(8) }} {% if not method.void %} # Return the response diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_base.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_base.py.j2 index b79785afc517..90c0e10d6403 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_base.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_base.py.j2 @@ -120,51 +120,8 @@ class _Base{{ service.name }}RestTransport({{service.name}}Transport): def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} {% endif %}{# required fields #} - {% set method_http_options = method.http_options %} - {{ shared_macros.http_options_method(method_http_options)|indent(8) }} - - @staticmethod - def _get_transcoded_request(http_options, request): - {% if method.input.ident.is_proto_plus_type %} - pb_request = {{method.input.ident}}.pb(request) - {% else %} - pb_request = request - {% endif %} - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - {% set body_spec = method.http_options[0].body %} - {%- if body_spec %} - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums={{ opts.rest_numeric_enums }} - ) - return body - - {%- endif %}{# body_spec #} - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums={{ opts.rest_numeric_enums }}, - )) - {% if method.input.required_fields %} - query_params.update(_Base{{ service.name }}RestTransport._Base{{method.name}}._get_unset_required_fields(query_params)) - {% endif %}{# required fields #} - - {% if opts.rest_numeric_enums %} - query_params["$alt"] = "json;enum-encoding=int" - {% endif %} - return query_params - {% endif %}{# method.http_options and not method.client_streaming #} {% endfor %} diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/_compat.py new file mode 100644 index 000000000000..6f17d9fcc3ea --- /dev/null +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/_compat.py @@ -0,0 +1,314 @@ +# # Copyright 2026 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. +# +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py index a9a4b4693298..83e0ef75d5b8 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py @@ -20,7 +20,7 @@ from google.auth import credentials as ga_credentials # type: ignore from google.api_core import exceptions as core_exceptions from google.api_core import retry as retries -from google.api_core import rest_helpers +from google.cloud.asset_v1 import _compat as rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 import google.protobuf @@ -1235,12 +1235,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy._get_http_options() - request, metadata = self._interceptor.pre_analyze_iam_policy(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy, + "_BaseAnalyzeIamPolicy__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1360,14 +1365,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_http_options() - request, metadata = self._interceptor.pre_analyze_iam_policy_longrunning(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning, + "_BaseAnalyzeIamPolicyLongrunning__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1482,12 +1490,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeMove._get_http_options() - request, metadata = self._interceptor.pre_analyze_move(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeMove._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeMove._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeMove, + "_BaseAnalyzeMove__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1604,12 +1617,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies._get_http_options() - request, metadata = self._interceptor.pre_analyze_org_policies(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies, + "_BaseAnalyzeOrgPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1727,12 +1745,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets._get_http_options() - request, metadata = self._interceptor.pre_analyze_org_policy_governed_assets(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets, + "_BaseAnalyzeOrgPolicyGovernedAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1850,12 +1873,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers._get_http_options() - request, metadata = self._interceptor.pre_analyze_org_policy_governed_containers(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers, + "_BaseAnalyzeOrgPolicyGovernedContainers__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1969,12 +1997,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory._get_http_options() - request, metadata = self._interceptor.pre_batch_get_assets_history(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory, + "_BaseBatchGetAssetsHistory__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2092,12 +2125,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies._get_http_options() - request, metadata = self._interceptor.pre_batch_get_effective_iam_policies(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies, + "_BaseBatchGetEffectiveIamPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2220,14 +2258,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseCreateFeed._get_http_options() - request, metadata = self._interceptor.pre_create_feed(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseCreateFeed._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseCreateFeed._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseCreateFeed._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseCreateFeed, + "_BaseCreateFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2344,14 +2385,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_http_options() - request, metadata = self._interceptor.pre_create_saved_query(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseCreateSavedQuery, + "_BaseCreateSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2461,12 +2505,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseDeleteFeed._get_http_options() - request, metadata = self._interceptor.pre_delete_feed(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseDeleteFeed._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseDeleteFeed._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseDeleteFeed, + "_BaseDeleteFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2546,12 +2595,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseDeleteSavedQuery._get_http_options() - request, metadata = self._interceptor.pre_delete_saved_query(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseDeleteSavedQuery._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseDeleteSavedQuery._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseDeleteSavedQuery, + "_BaseDeleteSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2639,14 +2693,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseExportAssets._get_http_options() - request, metadata = self._interceptor.pre_export_assets(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseExportAssets._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseExportAssets._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseExportAssets._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseExportAssets, + "_BaseExportAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2766,12 +2823,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseGetFeed._get_http_options() - request, metadata = self._interceptor.pre_get_feed(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseGetFeed._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseGetFeed._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseGetFeed, + "_BaseGetFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2887,12 +2949,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseGetSavedQuery._get_http_options() - request, metadata = self._interceptor.pre_get_saved_query(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseGetSavedQuery._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseGetSavedQuery._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseGetSavedQuery, + "_BaseGetSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3006,12 +3073,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseListAssets._get_http_options() - request, metadata = self._interceptor.pre_list_assets(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseListAssets._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseListAssets._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseListAssets, + "_BaseListAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3125,12 +3197,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseListFeeds._get_http_options() - request, metadata = self._interceptor.pre_list_feeds(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseListFeeds._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseListFeeds._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseListFeeds, + "_BaseListFeeds__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3244,12 +3321,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseListSavedQueries._get_http_options() - request, metadata = self._interceptor.pre_list_saved_queries(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseListSavedQueries._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseListSavedQueries._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseListSavedQueries, + "_BaseListSavedQueries__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3364,14 +3446,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseQueryAssets._get_http_options() - request, metadata = self._interceptor.pre_query_assets(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseQueryAssets._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseQueryAssets._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseQueryAssets._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseQueryAssets, + "_BaseQueryAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3485,12 +3570,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseSearchAllIamPolicies._get_http_options() - request, metadata = self._interceptor.pre_search_all_iam_policies(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseSearchAllIamPolicies._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseSearchAllIamPolicies._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseSearchAllIamPolicies, + "_BaseSearchAllIamPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3604,12 +3694,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseSearchAllResources._get_http_options() - request, metadata = self._interceptor.pre_search_all_resources(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseSearchAllResources._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseSearchAllResources._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseSearchAllResources, + "_BaseSearchAllResources__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3732,14 +3827,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseUpdateFeed._get_http_options() - request, metadata = self._interceptor.pre_update_feed(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseUpdateFeed._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseUpdateFeed._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseUpdateFeed._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseUpdateFeed, + "_BaseUpdateFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3856,14 +3954,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_http_options() - request, metadata = self._interceptor.pre_update_saved_query(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseUpdateSavedQuery, + "_BaseUpdateSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4165,12 +4266,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest_base.py index f635d0015fee..175f9c010f33 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest_base.py @@ -97,7 +97,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -107,22 +106,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeIamPolicyRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeIamPolicyLongrunning: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -133,7 +116,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -144,31 +126,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeIamPolicyLongrunningRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeMove: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -179,7 +136,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -189,22 +145,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeMoveRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeMove._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeOrgPolicies: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -215,7 +155,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -225,22 +164,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeOrgPoliciesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeOrgPolicyGovernedAssets: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -251,7 +174,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -261,22 +183,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeOrgPolicyGovernedAssetsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeOrgPolicyGovernedContainers: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -287,7 +193,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -297,22 +202,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeOrgPolicyGovernedContainersRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers._get_unset_required_fields(query_params)) - - return query_params - class _BaseBatchGetAssetsHistory: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -323,7 +212,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -333,22 +221,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.BatchGetAssetsHistoryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory._get_unset_required_fields(query_params)) - - return query_params - class _BaseBatchGetEffectiveIamPolicies: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -359,7 +231,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -369,22 +240,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.BatchGetEffectiveIamPoliciesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateFeed: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -395,7 +250,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -406,31 +260,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.CreateFeedRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseCreateFeed._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateSavedQuery: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -441,7 +270,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -452,31 +280,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.CreateSavedQueryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteFeed: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -487,7 +290,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -497,22 +299,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.DeleteFeedRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseDeleteFeed._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteSavedQuery: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -523,7 +309,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -533,22 +318,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.DeleteSavedQueryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseDeleteSavedQuery._get_unset_required_fields(query_params)) - - return query_params - class _BaseExportAssets: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -559,7 +328,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -570,31 +338,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.ExportAssetsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseExportAssets._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetFeed: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -605,7 +348,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -615,22 +357,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.GetFeedRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseGetFeed._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetSavedQuery: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -641,7 +367,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -651,22 +376,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.GetSavedQueryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseGetSavedQuery._get_unset_required_fields(query_params)) - - return query_params - class _BaseListAssets: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -677,7 +386,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -687,22 +395,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.ListAssetsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseListAssets._get_unset_required_fields(query_params)) - - return query_params - class _BaseListFeeds: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -713,7 +405,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -723,22 +414,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.ListFeedsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseListFeeds._get_unset_required_fields(query_params)) - - return query_params - class _BaseListSavedQueries: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -749,7 +424,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -759,22 +433,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.ListSavedQueriesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseListSavedQueries._get_unset_required_fields(query_params)) - - return query_params - class _BaseQueryAssets: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -785,7 +443,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -796,31 +453,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.QueryAssetsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseQueryAssets._get_unset_required_fields(query_params)) - - return query_params - class _BaseSearchAllIamPolicies: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -831,7 +463,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -841,22 +472,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.SearchAllIamPoliciesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseSearchAllIamPolicies._get_unset_required_fields(query_params)) - - return query_params - class _BaseSearchAllResources: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -867,7 +482,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -877,22 +491,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.SearchAllResourcesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseSearchAllResources._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateFeed: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -903,7 +501,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -914,31 +511,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.UpdateFeedRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseUpdateFeed._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateSavedQuery: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -949,7 +521,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -960,32 +531,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.UpdateSavedQueryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetOperation: + """Base class for GetOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -998,18 +545,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseAssetServiceRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/_compat.py new file mode 100644 index 000000000000..6f17d9fcc3ea --- /dev/null +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/_compat.py @@ -0,0 +1,314 @@ +# # Copyright 2026 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. +# +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py index f4969132838a..77573563b286 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py @@ -20,7 +20,7 @@ from google.auth import credentials as ga_credentials # type: ignore from google.api_core import exceptions as core_exceptions from google.api_core import retry as retries -from google.api_core import rest_helpers +from google.iam.credentials_v1 import _compat as rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 import google.protobuf @@ -414,14 +414,17 @@ def __call__(self, """ http_options = _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_http_options() - request, metadata = self._interceptor.pre_generate_access_token(request, metadata) - transcoded_request = _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_transcoded_request(http_options, request) - - body = _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken, + "_BaseGenerateAccessToken__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -536,14 +539,17 @@ def __call__(self, """ http_options = _BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_http_options() - request, metadata = self._interceptor.pre_generate_id_token(request, metadata) - transcoded_request = _BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_transcoded_request(http_options, request) - - body = _BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseIAMCredentialsRestTransport._BaseGenerateIdToken, + "_BaseGenerateIdToken__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -658,14 +664,17 @@ def __call__(self, """ http_options = _BaseIAMCredentialsRestTransport._BaseSignBlob._get_http_options() - request, metadata = self._interceptor.pre_sign_blob(request, metadata) - transcoded_request = _BaseIAMCredentialsRestTransport._BaseSignBlob._get_transcoded_request(http_options, request) - - body = _BaseIAMCredentialsRestTransport._BaseSignBlob._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseIAMCredentialsRestTransport._BaseSignBlob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseIAMCredentialsRestTransport._BaseSignBlob, + "_BaseSignBlob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -780,14 +789,17 @@ def __call__(self, """ http_options = _BaseIAMCredentialsRestTransport._BaseSignJwt._get_http_options() - request, metadata = self._interceptor.pre_sign_jwt(request, metadata) - transcoded_request = _BaseIAMCredentialsRestTransport._BaseSignJwt._get_transcoded_request(http_options, request) - - body = _BaseIAMCredentialsRestTransport._BaseSignJwt._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseIAMCredentialsRestTransport._BaseSignJwt._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseIAMCredentialsRestTransport._BaseSignJwt, + "_BaseSignJwt__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest_base.py index db587944901a..5619f62ae96a 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest_base.py @@ -95,7 +95,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -106,31 +105,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = common.GenerateAccessTokenRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_unset_required_fields(query_params)) - - return query_params - class _BaseGenerateIdToken: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -141,7 +115,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -152,31 +125,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = common.GenerateIdTokenRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_unset_required_fields(query_params)) - - return query_params - class _BaseSignBlob: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -187,7 +135,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -198,31 +145,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = common.SignBlobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseIAMCredentialsRestTransport._BaseSignBlob._get_unset_required_fields(query_params)) - - return query_params - class _BaseSignJwt: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -233,7 +155,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -244,31 +165,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = common.SignJwtRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseIAMCredentialsRestTransport._BaseSignJwt._get_unset_required_fields(query_params)) - - return query_params - __all__=( '_BaseIAMCredentialsRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/_compat.py new file mode 100644 index 000000000000..6f17d9fcc3ea --- /dev/null +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/_compat.py @@ -0,0 +1,314 @@ +# # Copyright 2026 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. +# +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py index fb9a5c2a8c26..a18814177a38 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py @@ -20,7 +20,7 @@ from google.auth import credentials as ga_credentials # type: ignore from google.api_core import exceptions as core_exceptions from google.api_core import retry as retries -from google.api_core import rest_helpers +from google.cloud.eventarc_v1 import _compat as rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 import google.protobuf @@ -2206,14 +2206,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateChannel._get_http_options() - request, metadata = self._interceptor.pre_create_channel(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateChannel._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateChannel._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateChannel._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateChannel, + "_BaseCreateChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2330,14 +2333,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateChannelConnection._get_http_options() - request, metadata = self._interceptor.pre_create_channel_connection(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateChannelConnection._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateChannelConnection._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateChannelConnection._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateChannelConnection, + "_BaseCreateChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2454,14 +2460,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateEnrollment._get_http_options() - request, metadata = self._interceptor.pre_create_enrollment(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateEnrollment._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateEnrollment._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateEnrollment._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateEnrollment, + "_BaseCreateEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2578,14 +2587,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_http_options() - request, metadata = self._interceptor.pre_create_google_api_source(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateGoogleApiSource, + "_BaseCreateGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2702,14 +2714,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateMessageBus._get_http_options() - request, metadata = self._interceptor.pre_create_message_bus(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateMessageBus._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateMessageBus._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateMessageBus._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateMessageBus, + "_BaseCreateMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2826,14 +2841,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreatePipeline._get_http_options() - request, metadata = self._interceptor.pre_create_pipeline(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreatePipeline._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreatePipeline._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreatePipeline._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreatePipeline, + "_BaseCreatePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2950,14 +2968,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateTrigger._get_http_options() - request, metadata = self._interceptor.pre_create_trigger(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateTrigger._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateTrigger._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateTrigger._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateTrigger, + "_BaseCreateTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3073,12 +3094,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteChannel._get_http_options() - request, metadata = self._interceptor.pre_delete_channel(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteChannel._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteChannel._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteChannel, + "_BaseDeleteChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3194,12 +3220,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteChannelConnection._get_http_options() - request, metadata = self._interceptor.pre_delete_channel_connection(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteChannelConnection._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteChannelConnection._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteChannelConnection, + "_BaseDeleteChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3315,12 +3346,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteEnrollment._get_http_options() - request, metadata = self._interceptor.pre_delete_enrollment(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteEnrollment._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteEnrollment._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteEnrollment, + "_BaseDeleteEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3436,12 +3472,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteGoogleApiSource._get_http_options() - request, metadata = self._interceptor.pre_delete_google_api_source(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteGoogleApiSource._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteGoogleApiSource._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteGoogleApiSource, + "_BaseDeleteGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3557,12 +3598,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteMessageBus._get_http_options() - request, metadata = self._interceptor.pre_delete_message_bus(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteMessageBus._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteMessageBus._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteMessageBus, + "_BaseDeleteMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3678,12 +3724,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeletePipeline._get_http_options() - request, metadata = self._interceptor.pre_delete_pipeline(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeletePipeline._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeletePipeline._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeletePipeline, + "_BaseDeletePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3799,12 +3850,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteTrigger._get_http_options() - request, metadata = self._interceptor.pre_delete_trigger(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteTrigger._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteTrigger._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteTrigger, + "_BaseDeleteTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3925,12 +3981,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetChannel._get_http_options() - request, metadata = self._interceptor.pre_get_channel(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetChannel._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetChannel._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetChannel, + "_BaseGetChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4052,12 +4113,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetChannelConnection._get_http_options() - request, metadata = self._interceptor.pre_get_channel_connection(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetChannelConnection._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetChannelConnection._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetChannelConnection, + "_BaseGetChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4178,12 +4244,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetEnrollment._get_http_options() - request, metadata = self._interceptor.pre_get_enrollment(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetEnrollment._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetEnrollment._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetEnrollment, + "_BaseGetEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4301,12 +4372,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetGoogleApiSource._get_http_options() - request, metadata = self._interceptor.pre_get_google_api_source(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetGoogleApiSource._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetGoogleApiSource._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetGoogleApiSource, + "_BaseGetGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4429,12 +4505,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetGoogleChannelConfig._get_http_options() - request, metadata = self._interceptor.pre_get_google_channel_config(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetGoogleChannelConfig._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetGoogleChannelConfig._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetGoogleChannelConfig, + "_BaseGetGoogleChannelConfig__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4557,12 +4638,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetMessageBus._get_http_options() - request, metadata = self._interceptor.pre_get_message_bus(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetMessageBus._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetMessageBus._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetMessageBus, + "_BaseGetMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4679,12 +4765,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetPipeline._get_http_options() - request, metadata = self._interceptor.pre_get_pipeline(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetPipeline._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetPipeline._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetPipeline, + "_BaseGetPipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4801,12 +4892,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetProvider._get_http_options() - request, metadata = self._interceptor.pre_get_provider(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetProvider._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetProvider._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetProvider, + "_BaseGetProvider__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4923,12 +5019,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetTrigger._get_http_options() - request, metadata = self._interceptor.pre_get_trigger(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetTrigger._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetTrigger._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetTrigger, + "_BaseGetTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5045,12 +5146,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListChannelConnections._get_http_options() - request, metadata = self._interceptor.pre_list_channel_connections(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListChannelConnections._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListChannelConnections._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListChannelConnections, + "_BaseListChannelConnections__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5165,12 +5271,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListChannels._get_http_options() - request, metadata = self._interceptor.pre_list_channels(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListChannels._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListChannels._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListChannels, + "_BaseListChannels__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5285,12 +5396,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListEnrollments._get_http_options() - request, metadata = self._interceptor.pre_list_enrollments(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListEnrollments._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListEnrollments._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListEnrollments, + "_BaseListEnrollments__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5407,12 +5523,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListGoogleApiSources._get_http_options() - request, metadata = self._interceptor.pre_list_google_api_sources(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListGoogleApiSources._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListGoogleApiSources._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListGoogleApiSources, + "_BaseListGoogleApiSources__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5530,12 +5651,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListMessageBusEnrollments._get_http_options() - request, metadata = self._interceptor.pre_list_message_bus_enrollments(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListMessageBusEnrollments._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListMessageBusEnrollments._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListMessageBusEnrollments, + "_BaseListMessageBusEnrollments__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5652,12 +5778,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListMessageBuses._get_http_options() - request, metadata = self._interceptor.pre_list_message_buses(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListMessageBuses._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListMessageBuses._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListMessageBuses, + "_BaseListMessageBuses__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5774,12 +5905,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListPipelines._get_http_options() - request, metadata = self._interceptor.pre_list_pipelines(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListPipelines._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListPipelines._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListPipelines, + "_BaseListPipelines__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5894,12 +6030,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListProviders._get_http_options() - request, metadata = self._interceptor.pre_list_providers(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListProviders._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListProviders._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListProviders, + "_BaseListProviders__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6014,12 +6155,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListTriggers._get_http_options() - request, metadata = self._interceptor.pre_list_triggers(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListTriggers._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListTriggers._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListTriggers, + "_BaseListTriggers__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6138,14 +6284,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateChannel._get_http_options() - request, metadata = self._interceptor.pre_update_channel(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateChannel._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateChannel._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateChannel._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateChannel, + "_BaseUpdateChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6262,14 +6411,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateEnrollment._get_http_options() - request, metadata = self._interceptor.pre_update_enrollment(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateEnrollment._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateEnrollment._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateEnrollment._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateEnrollment, + "_BaseUpdateEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6386,14 +6538,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_http_options() - request, metadata = self._interceptor.pre_update_google_api_source(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateGoogleApiSource, + "_BaseUpdateGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6516,14 +6671,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_http_options() - request, metadata = self._interceptor.pre_update_google_channel_config(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig, + "_BaseUpdateGoogleChannelConfig__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6642,14 +6800,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateMessageBus._get_http_options() - request, metadata = self._interceptor.pre_update_message_bus(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateMessageBus._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateMessageBus._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateMessageBus._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateMessageBus, + "_BaseUpdateMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6766,14 +6927,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdatePipeline._get_http_options() - request, metadata = self._interceptor.pre_update_pipeline(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdatePipeline._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdatePipeline._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdatePipeline._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdatePipeline, + "_BaseUpdatePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6890,14 +7054,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateTrigger._get_http_options() - request, metadata = self._interceptor.pre_update_trigger(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateTrigger._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateTrigger._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateTrigger._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateTrigger, + "_BaseUpdateTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7325,12 +7492,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetLocation._get_http_options() - request, metadata = self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7443,12 +7615,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListLocations._get_http_options() - request, metadata = self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7561,12 +7738,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetIamPolicy._get_http_options() - request, metadata = self._interceptor.pre_get_iam_policy(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetIamPolicy._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetIamPolicy._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetIamPolicy, + "_BaseGetIamPolicy__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7680,14 +7862,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseSetIamPolicy._get_http_options() - request, metadata = self._interceptor.pre_set_iam_policy(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseSetIamPolicy._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseSetIamPolicy._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseSetIamPolicy._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseSetIamPolicy, + "_BaseSetIamPolicy__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7801,14 +7986,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseTestIamPermissions._get_http_options() - request, metadata = self._interceptor.pre_test_iam_permissions(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseTestIamPermissions._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseTestIamPermissions._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseTestIamPermissions._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseTestIamPermissions, + "_BaseTestIamPermissions__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7919,14 +8107,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCancelOperation._get_http_options() - request, metadata = self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCancelOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -8013,12 +8204,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -8108,12 +8304,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -8226,12 +8427,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListOperations._get_http_options() - request, metadata = self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest_base.py index 0405ac986903..d78e8158be41 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest_base.py @@ -109,7 +109,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -120,31 +119,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateChannelRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateChannel._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateChannelConnection: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -155,7 +129,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -166,31 +139,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateChannelConnectionRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateChannelConnection._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateEnrollment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -201,7 +149,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -212,31 +159,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateEnrollmentRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateEnrollment._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateGoogleApiSource: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -247,7 +169,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -258,31 +179,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateGoogleApiSourceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateMessageBus: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -293,7 +189,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -304,31 +199,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateMessageBusRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateMessageBus._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreatePipeline: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -339,7 +209,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -350,31 +219,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreatePipelineRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreatePipeline._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateTrigger: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -385,7 +229,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -396,31 +239,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateTriggerRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateTrigger._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteChannel: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -431,7 +249,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -441,22 +258,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteChannelRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteChannel._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteChannelConnection: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -467,7 +268,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -477,22 +277,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteChannelConnectionRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteChannelConnection._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteEnrollment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -503,7 +287,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -513,22 +296,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteEnrollmentRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteEnrollment._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteGoogleApiSource: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -539,7 +306,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -549,22 +315,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteGoogleApiSourceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteGoogleApiSource._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteMessageBus: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -575,7 +325,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -585,22 +334,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteMessageBusRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteMessageBus._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeletePipeline: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -611,7 +344,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -621,22 +353,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeletePipelineRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeletePipeline._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteTrigger: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -647,7 +363,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -657,22 +372,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteTriggerRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteTrigger._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetChannel: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -683,7 +382,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -693,22 +391,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetChannelRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetChannel._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetChannelConnection: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -719,7 +401,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -729,22 +410,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetChannelConnectionRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetChannelConnection._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetEnrollment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -755,7 +420,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -765,22 +429,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetEnrollmentRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetEnrollment._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetGoogleApiSource: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -791,7 +439,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -801,22 +448,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetGoogleApiSourceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetGoogleApiSource._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetGoogleChannelConfig: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -827,7 +458,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -837,22 +467,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetGoogleChannelConfigRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetGoogleChannelConfig._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetMessageBus: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -863,7 +477,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -873,22 +486,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetMessageBusRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetMessageBus._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetPipeline: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -899,7 +496,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -909,22 +505,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetPipelineRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetPipeline._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetProvider: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -935,7 +515,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -945,22 +524,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetProviderRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetProvider._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetTrigger: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -971,7 +534,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -981,22 +543,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetTriggerRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetTrigger._get_unset_required_fields(query_params)) - - return query_params - class _BaseListChannelConnections: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1007,7 +553,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1017,22 +562,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListChannelConnectionsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListChannelConnections._get_unset_required_fields(query_params)) - - return query_params - class _BaseListChannels: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1043,7 +572,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1053,22 +581,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListChannelsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListChannels._get_unset_required_fields(query_params)) - - return query_params - class _BaseListEnrollments: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1079,7 +591,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1089,22 +600,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListEnrollmentsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListEnrollments._get_unset_required_fields(query_params)) - - return query_params - class _BaseListGoogleApiSources: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1115,7 +610,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1125,22 +619,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListGoogleApiSourcesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListGoogleApiSources._get_unset_required_fields(query_params)) - - return query_params - class _BaseListMessageBusEnrollments: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1151,7 +629,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1161,22 +638,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListMessageBusEnrollmentsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListMessageBusEnrollments._get_unset_required_fields(query_params)) - - return query_params - class _BaseListMessageBuses: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1187,7 +648,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1197,22 +657,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListMessageBusesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListMessageBuses._get_unset_required_fields(query_params)) - - return query_params - class _BaseListPipelines: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1223,7 +667,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1233,22 +676,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListPipelinesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListPipelines._get_unset_required_fields(query_params)) - - return query_params - class _BaseListProviders: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1259,7 +686,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1269,22 +695,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListProvidersRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListProviders._get_unset_required_fields(query_params)) - - return query_params - class _BaseListTriggers: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1295,7 +705,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1305,22 +714,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListTriggersRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListTriggers._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateChannel: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1335,30 +728,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateChannelRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - - return query_params - class _BaseUpdateEnrollment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1369,7 +738,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1380,31 +748,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateEnrollmentRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdateEnrollment._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateGoogleApiSource: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1415,7 +758,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1426,31 +768,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateGoogleApiSourceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateGoogleChannelConfig: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1461,7 +778,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1472,31 +788,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateGoogleChannelConfigRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateMessageBus: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1507,7 +798,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1518,31 +808,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateMessageBusRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdateMessageBus._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdatePipeline: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1553,7 +818,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1564,31 +828,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdatePipelineRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdatePipeline._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateTrigger: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1603,31 +842,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateTriggerRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - - return query_params - class _BaseGetLocation: + """Base class for GetLocation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1640,19 +856,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListLocations: + """Base class for ListLocations REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1665,19 +870,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetIamPolicy: + """Base class for GetIamPolicy REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1698,19 +892,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseSetIamPolicy: + """Base class for SetIamPolicy REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1734,23 +917,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseTestIamPermissions: + """Base class for TestIamPermissions REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1774,23 +942,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseCancelOperation: + """Base class for CancelOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1804,23 +957,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseDeleteOperation: + """Base class for DeleteOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1833,19 +971,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetOperation: + """Base class for GetOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1858,19 +985,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListOperations: + """Base class for ListOperations REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1883,18 +999,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseEventarcRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/_compat.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/_compat.py new file mode 100644 index 000000000000..3bb07e7d2b4b --- /dev/null +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/_compat.py @@ -0,0 +1,315 @@ +# # Copyright 2026 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. +# + +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/_compat.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/_compat.py new file mode 100644 index 000000000000..6f17d9fcc3ea --- /dev/null +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/_compat.py @@ -0,0 +1,314 @@ +# # Copyright 2026 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. +# +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/_compat.py new file mode 100644 index 000000000000..6f17d9fcc3ea --- /dev/null +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/_compat.py @@ -0,0 +1,314 @@ +# # Copyright 2026 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. +# +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py index 013062f304b2..8b3ff81f649f 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py @@ -20,7 +20,7 @@ from google.auth import credentials as ga_credentials # type: ignore from google.api_core import exceptions as core_exceptions from google.api_core import retry as retries -from google.api_core import rest_helpers +from google.cloud.redis_v1 import _compat as rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 import google.protobuf @@ -944,14 +944,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCreateInstance._get_http_options() - request, metadata = self._interceptor.pre_create_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCreateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseCreateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCreateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1067,12 +1070,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_http_options() - request, metadata = self._interceptor.pre_delete_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1189,14 +1197,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseExportInstance._get_http_options() - request, metadata = self._interceptor.pre_export_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseExportInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseExportInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseExportInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseExportInstance, + "_BaseExportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1313,14 +1324,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_http_options() - request, metadata = self._interceptor.pre_failover_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseFailoverInstance, + "_BaseFailoverInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1433,12 +1447,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstance._get_http_options() - request, metadata = self._interceptor.pre_get_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1553,12 +1572,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_http_options() - request, metadata = self._interceptor.pre_get_instance_auth_string(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstanceAuthString, + "_BaseGetInstanceAuthString__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1677,14 +1701,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseImportInstance._get_http_options() - request, metadata = self._interceptor.pre_import_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseImportInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseImportInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseImportInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseImportInstance, + "_BaseImportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1799,12 +1826,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListInstances._get_http_options() - request, metadata = self._interceptor.pre_list_instances(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListInstances._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListInstances._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1923,14 +1955,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_http_options() - request, metadata = self._interceptor.pre_reschedule_maintenance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseRescheduleMaintenance, + "_BaseRescheduleMaintenance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2047,14 +2082,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_http_options() - request, metadata = self._interceptor.pre_update_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2171,14 +2209,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_http_options() - request, metadata = self._interceptor.pre_upgrade_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpgradeInstance, + "_BaseUpgradeInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2382,12 +2423,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetLocation._get_http_options() - request, metadata = self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2500,12 +2546,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListLocations._get_http_options() - request, metadata = self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2615,12 +2666,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCancelOperation._get_http_options() - request, metadata = self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2707,12 +2763,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2802,12 +2863,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2920,12 +2986,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListOperations._get_http_options() - request, metadata = self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3039,14 +3110,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseWaitOperation._get_http_options() - request, metadata = self._interceptor.pre_wait_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseWaitOperation._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseWaitOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseWaitOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseWaitOperation, + "_BaseWaitOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py index d827de47ee24..5867f95994b6 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py @@ -30,7 +30,7 @@ from google.api_core import operations_v1 from google.cloud.location import locations_pb2 # type: ignore from google.api_core import retry_async as retries -from google.api_core import rest_helpers +from google.cloud.redis_v1 import _compat as rest_helpers from google.api_core import rest_streaming_async # type: ignore import google.protobuf @@ -969,14 +969,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCreateInstance._get_http_options() - request, metadata = await self._interceptor.pre_create_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCreateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseCreateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCreateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1098,12 +1101,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_http_options() - request, metadata = await self._interceptor.pre_delete_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1226,14 +1234,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseExportInstance._get_http_options() - request, metadata = await self._interceptor.pre_export_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseExportInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseExportInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseExportInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseExportInstance, + "_BaseExportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1356,14 +1367,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_http_options() - request, metadata = await self._interceptor.pre_failover_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseFailoverInstance, + "_BaseFailoverInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1482,12 +1496,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstance._get_http_options() - request, metadata = await self._interceptor.pre_get_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1606,12 +1625,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_http_options() - request, metadata = await self._interceptor.pre_get_instance_auth_string(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstanceAuthString, + "_BaseGetInstanceAuthString__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1734,14 +1758,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseImportInstance._get_http_options() - request, metadata = await self._interceptor.pre_import_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseImportInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseImportInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseImportInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseImportInstance, + "_BaseImportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1862,12 +1889,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListInstances._get_http_options() - request, metadata = await self._interceptor.pre_list_instances(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListInstances._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListInstances._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1990,14 +2022,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_http_options() - request, metadata = await self._interceptor.pre_reschedule_maintenance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseRescheduleMaintenance, + "_BaseRescheduleMaintenance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2120,14 +2155,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_http_options() - request, metadata = await self._interceptor.pre_update_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2250,14 +2288,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_http_options() - request, metadata = await self._interceptor.pre_upgrade_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpgradeInstance, + "_BaseUpgradeInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2501,12 +2542,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetLocation._get_http_options() - request, metadata = await self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2623,12 +2669,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListLocations._get_http_options() - request, metadata = await self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2742,12 +2793,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCancelOperation._get_http_options() - request, metadata = await self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2838,12 +2894,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = await self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2937,12 +2998,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetOperation._get_http_options() - request, metadata = await self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3059,12 +3125,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListOperations._get_http_options() - request, metadata = await self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3182,14 +3253,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseWaitOperation._get_http_options() - request, metadata = await self._interceptor.pre_wait_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseWaitOperation._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseWaitOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseWaitOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseWaitOperation, + "_BaseWaitOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py index 65352deb5bbf..48fb3713325a 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py @@ -97,7 +97,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -108,31 +107,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.CreateInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseCreateInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -143,7 +117,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -153,22 +126,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.DeleteInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseDeleteInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseExportInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -179,7 +136,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -190,31 +146,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.ExportInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseExportInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseFailoverInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -225,7 +156,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -236,31 +166,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.FailoverInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseFailoverInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -271,7 +176,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -281,22 +185,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.GetInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseGetInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetInstanceAuthString: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -307,7 +195,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -317,22 +204,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.GetInstanceAuthStringRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_unset_required_fields(query_params)) - - return query_params - class _BaseImportInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -343,7 +214,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -354,31 +224,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.ImportInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseImportInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseListInstances: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -389,7 +234,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -399,22 +243,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.ListInstancesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseListInstances._get_unset_required_fields(query_params)) - - return query_params - class _BaseRescheduleMaintenance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -425,7 +253,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -436,31 +263,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.RescheduleMaintenanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -471,7 +273,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -482,31 +283,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.UpdateInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseUpdateInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpgradeInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -517,7 +293,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -528,32 +303,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.UpgradeInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseUpgradeInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetLocation: + """Base class for GetLocation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -566,19 +317,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListLocations: + """Base class for ListLocations REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -591,19 +331,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseCancelOperation: + """Base class for CancelOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -616,19 +345,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseDeleteOperation: + """Base class for DeleteOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -641,19 +359,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetOperation: + """Base class for GetOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -666,19 +373,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListOperations: + """Base class for ListOperations REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -691,19 +387,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseWaitOperation: + """Base class for WaitOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -717,22 +402,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseCloudRedisRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/_compat.py new file mode 100644 index 000000000000..6f17d9fcc3ea --- /dev/null +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/_compat.py @@ -0,0 +1,314 @@ +# # Copyright 2026 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. +# +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py index 230965c05d9c..c0f1aa7277fa 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py @@ -20,7 +20,7 @@ from google.auth import credentials as ga_credentials # type: ignore from google.api_core import exceptions as core_exceptions from google.api_core import retry as retries -from google.api_core import rest_helpers +from google.cloud.redis_v1 import _compat as rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 import google.protobuf @@ -680,14 +680,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCreateInstance._get_http_options() - request, metadata = self._interceptor.pre_create_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCreateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseCreateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCreateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -803,12 +806,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_http_options() - request, metadata = self._interceptor.pre_delete_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -921,12 +929,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstance._get_http_options() - request, metadata = self._interceptor.pre_get_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1043,12 +1056,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListInstances._get_http_options() - request, metadata = self._interceptor.pre_list_instances(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListInstances._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListInstances._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1167,14 +1185,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_http_options() - request, metadata = self._interceptor.pre_update_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1330,12 +1351,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetLocation._get_http_options() - request, metadata = self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1448,12 +1474,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListLocations._get_http_options() - request, metadata = self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1563,12 +1594,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCancelOperation._get_http_options() - request, metadata = self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1655,12 +1691,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1750,12 +1791,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1868,12 +1914,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListOperations._get_http_options() - request, metadata = self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1987,14 +2038,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseWaitOperation._get_http_options() - request, metadata = self._interceptor.pre_wait_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseWaitOperation._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseWaitOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseWaitOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseWaitOperation, + "_BaseWaitOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py index bcd5f851f97f..af14341a415a 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py @@ -30,7 +30,7 @@ from google.api_core import operations_v1 from google.cloud.location import locations_pb2 # type: ignore from google.api_core import retry_async as retries -from google.api_core import rest_helpers +from google.cloud.redis_v1 import _compat as rest_helpers from google.api_core import rest_streaming_async # type: ignore import google.protobuf @@ -675,14 +675,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCreateInstance._get_http_options() - request, metadata = await self._interceptor.pre_create_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCreateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseCreateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCreateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -804,12 +807,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_http_options() - request, metadata = await self._interceptor.pre_delete_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -928,12 +936,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstance._get_http_options() - request, metadata = await self._interceptor.pre_get_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1054,12 +1067,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListInstances._get_http_options() - request, metadata = await self._interceptor.pre_list_instances(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListInstances._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListInstances._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1182,14 +1200,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_http_options() - request, metadata = await self._interceptor.pre_update_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1397,12 +1418,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetLocation._get_http_options() - request, metadata = await self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1519,12 +1545,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListLocations._get_http_options() - request, metadata = await self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1638,12 +1669,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCancelOperation._get_http_options() - request, metadata = await self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1734,12 +1770,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = await self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1833,12 +1874,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetOperation._get_http_options() - request, metadata = await self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1955,12 +2001,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListOperations._get_http_options() - request, metadata = await self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2078,14 +2129,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseWaitOperation._get_http_options() - request, metadata = await self._interceptor.pre_wait_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseWaitOperation._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseWaitOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseWaitOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseWaitOperation, + "_BaseWaitOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py index ff18d15f1290..e280cdcbb135 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py @@ -97,7 +97,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -108,31 +107,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.CreateInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseCreateInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -143,7 +117,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -153,22 +126,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.DeleteInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseDeleteInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -179,7 +136,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -189,22 +145,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.GetInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseGetInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseListInstances: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -215,7 +155,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -225,22 +164,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.ListInstancesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseListInstances._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -251,7 +174,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -262,32 +184,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.UpdateInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseUpdateInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetLocation: + """Base class for GetLocation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -300,19 +198,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListLocations: + """Base class for ListLocations REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -325,19 +212,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseCancelOperation: + """Base class for CancelOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -350,19 +226,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseDeleteOperation: + """Base class for DeleteOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -375,19 +240,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetOperation: + """Base class for GetOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -400,19 +254,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListOperations: + """Base class for ListOperations REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -425,19 +268,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseWaitOperation: + """Base class for WaitOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -451,22 +283,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseCloudRedisRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/_compat.py new file mode 100644 index 000000000000..6f17d9fcc3ea --- /dev/null +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/_compat.py @@ -0,0 +1,314 @@ +# # Copyright 2026 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. +# +"""A compatibility module for older versions of google-api-core.""" + +import functools +import json +import operator +import os +import re +import uuid +from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from google.auth.exceptions import MutualTLSChannelError +import google.protobuf.message + + +try: + from google.api_core.universe import ( + get_default_mtls_endpoint, + get_api_endpoint, + get_universe_domain, + ) +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + def get_default_mtls_endpoint(api_endpoint: Optional[str]) -> Optional[str]: + """Converts api endpoint to mTLS endpoint.""" + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + if m is None: + # Could not parse api_endpoint; return as-is. + return api_endpoint + + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + def get_api_endpoint( + api_override: Optional[str], + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + universe_domain: str, + use_mtls_endpoint: str, + default_universe: str, + default_mtls_endpoint: Optional[str], + default_endpoint_template: str, + ) -> Optional[str]: + """Return the API endpoint used by the client.""" + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or (use_mtls_endpoint == "auto" and client_cert_source): + if universe_domain != default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {default_universe}." + ) + api_endpoint = default_mtls_endpoint + else: + api_endpoint = default_endpoint_template.format(UNIVERSE_DOMAIN=universe_domain) + return api_endpoint + + def get_universe_domain( + client_universe_domain: Optional[str], + universe_domain_env: Optional[str], + default_universe: str, + ) -> str: + """Return the universe domain used by the client.""" + universe_domain = default_universe + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + +try: + from google.api_core.gapic_v1.config import ( + use_client_cert_effective, + get_client_cert_source, + read_environment_variables, + ) +except ImportError: + from google.auth.transport import mtls # type: ignore + + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + + def use_client_cert_effective() -> bool: + """Returns whether client certificate should be used for mTLS.""" + if hasattr(mtls, "should_use_client_cert"): + return mtls.should_use_client_cert() + else: + use_client_cert_str = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false").lower() + if use_client_cert_str not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be" + " either `true` or `false`" + ) + return use_client_cert_str == "true" + + def get_client_cert_source( + provided_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]], + use_cert_flag: bool, + ) -> Optional[Callable[[], Tuple[bytes, bytes]]]: + """Return the client cert source to be used by the client.""" + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif ( + hasattr(mtls, "has_default_client_cert_source") + and mtls.has_default_client_cert_source() + ): + client_cert_source = mtls.default_client_cert_source() + else: + raise ValueError( + "Client certificate is required for mTLS, but no client certificate source was provided or found." + ) + return client_cert_source + + def read_environment_variables() -> Tuple[bool, str, Optional[str]]: + """Returns the environment variables used by the client.""" + use_client_cert = use_client_cert_effective() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` " + "must be `never`, `auto` or `always`" + ) + return use_client_cert, use_mtls_endpoint, universe_domain_env + + +try: + from google.api_core.gapic_v1.request import setup_request_id # type: ignore +except ImportError: + # TODO(https://github.com/googleapis/google-cloud-python/issues/17813): Remove this fallback when google-api-core >= 2.26.0 is the minimum required version. + def setup_request_id(request, field_name: str, is_proto3_optional: bool): + """Populate a UUID4 field in the request if it is not already set. + + Args: + request (Union[google.protobuf.message.Message, dict]): The request object. + field_name (str): The name of the field to populate. + is_proto3_optional (bool): Whether the field is proto3 optional. + """ + request_id_val = str(uuid.uuid4()) + if request is None: + return + + if isinstance(request, dict): + if is_proto3_optional: + if field_name not in request or request[field_name] is None: + request[field_name] = request_id_val + elif not request.get(field_name): + request[field_name] = request_id_val + return + + if is_proto3_optional: + try: + # Pure protobuf messages + if not request.HasField(field_name): + setattr(request, field_name, request_id_val) + except (AttributeError, ValueError): + # Proto-plus messages or other objects + if getattr(request, field_name, None) is None: + setattr(request, field_name, request_id_val) + else: + if not getattr(request, field_name, None): + setattr(request, field_name, request_id_val) + + +try: + from google.api_core.rest_helpers import ( # type: ignore + flatten_query_params, + transcode_request as _core_transcode_request, + ) + import inspect + if "rest_numeric_enums" not in inspect.signature(_core_transcode_request).parameters: + raise ImportError + transcode_request = _core_transcode_request +except (ImportError, AttributeError): # pragma: NO COVER + # TODO: Remove these fallbacks when google-api-core >= 2.18.0 is the minimum required version. + from google.protobuf import json_format # type: ignore + from google.api_core import path_template # type: ignore + + def flatten_query_params(obj, strict=False): # pragma: NO COVER + if obj is not None and not isinstance(obj, dict): + raise TypeError("flatten_query_params must be called with dict object") + return _flatten(obj, key_path=[], strict=strict) + + def _flatten(obj, key_path, strict=False): # pragma: NO COVER + if obj is None: + return [] + if isinstance(obj, dict): + return _flatten_dict(obj, key_path=key_path, strict=strict) + if isinstance(obj, list): + return _flatten_list(obj, key_path=key_path, strict=strict) + return _flatten_value(obj, key_path=key_path, strict=strict) + + def _is_primitive_value(obj): # pragma: NO COVER + if obj is None: + return False + if isinstance(obj, (list, dict)): + raise ValueError("query params may not contain repeated dicts or lists") + return True + + def _flatten_value(obj, key_path, strict=False): # pragma: NO COVER + return [(".".join(key_path), _canonicalize(obj, strict=strict))] + + def _flatten_dict(obj, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten(value, key_path=key_path + [key], strict=strict) + for key, value in obj.items() + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _flatten_list(elems, key_path, strict=False): # pragma: NO COVER + items = ( + _flatten_value(elem, key_path=key_path, strict=strict) + for elem in elems + if _is_primitive_value(elem) + ) + return functools.reduce(operator.concat, items, []) # type: ignore + + def _canonicalize(obj, strict=False): # pragma: NO COVER + if strict: + value = str(obj) + if isinstance(obj, bool): + value = value.lower() + return value + return obj + + def transcode_request( # pragma: NO COVER + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, + ) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + pb_request = getattr(request, "_pb", request) + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + if required_fields_default_values: + matched_option = None + for option in http_options: + if option.get("method", "").lower() == transcoded_request.get("method", "").lower(): + if path_template.validate( + option.get("uri", ""), transcoded_request.get("uri", "") + ): + matched_option = option + break + + bound_fields = set() + if matched_option: + uri_template = matched_option.get("uri", "") + for m in path_template._VARIABLE_RE.finditer(uri_template): + name = m.group("name") + if name: + bound_fields.add(name.split(".")[0]) + body_param = matched_option.get("body") + if body_param: + if body_param == "*": + bound_fields = None + else: + bound_fields.add(body_param.split(".")[0]) + + if bound_fields is not None: + for k, v in required_fields_default_values.items(): + if k in bound_fields: + continue + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py index 06ea5eab316d..7af48cf9f42f 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py @@ -20,7 +20,7 @@ from google.auth import credentials as ga_credentials # type: ignore from google.api_core import exceptions as core_exceptions from google.api_core import retry as retries -from google.api_core import rest_helpers +from google.cloud.storagebatchoperations_v1 import _compat as rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 import google.protobuf @@ -691,14 +691,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_http_options() - request, metadata = self._interceptor.pre_cancel_job(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_transcoded_request(http_options, request) - - body = _BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseCancelJob, + "_BaseCancelJob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -816,14 +819,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_http_options() - request, metadata = self._interceptor.pre_create_job(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_transcoded_request(http_options, request) - - body = _BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseCreateJob, + "_BaseCreateJob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -931,12 +937,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseDeleteJob._get_http_options() - request, metadata = self._interceptor.pre_delete_job(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseDeleteJob._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseDeleteJob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseDeleteJob, + "_BaseDeleteJob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1023,12 +1034,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation._get_http_options() - request, metadata = self._interceptor.pre_get_bucket_operation(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation, + "_BaseGetBucketOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1144,12 +1160,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseGetJob._get_http_options() - request, metadata = self._interceptor.pre_get_job(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseGetJob._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseGetJob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseGetJob, + "_BaseGetJob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1266,12 +1287,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseListBucketOperations._get_http_options() - request, metadata = self._interceptor.pre_list_bucket_operations(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseListBucketOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseListBucketOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseListBucketOperations, + "_BaseListBucketOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1385,12 +1411,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseListJobs._get_http_options() - request, metadata = self._interceptor.pre_list_jobs(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseListJobs._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseListJobs._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseListJobs, + "_BaseListJobs__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1564,12 +1595,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseGetLocation._get_http_options() - request, metadata = self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1682,12 +1718,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseListLocations._get_http_options() - request, metadata = self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1798,14 +1839,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseCancelOperation._get_http_options() - request, metadata = self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - body = _BaseStorageBatchOperationsRestTransport._BaseCancelOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1892,12 +1936,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1987,12 +2036,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2105,12 +2159,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseListOperations._get_http_options() - request, metadata = self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = rest_helpers.transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest_base.py index 280692aac74f..31006f98d738 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest_base.py @@ -99,7 +99,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -110,31 +109,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.CancelJobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateJob: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -145,7 +119,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -156,31 +129,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.CreateJobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteJob: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -191,7 +139,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -201,22 +148,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.DeleteJobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseDeleteJob._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetBucketOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -227,7 +158,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -237,22 +167,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.GetBucketOperationRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetJob: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -263,7 +177,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -273,22 +186,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.GetJobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseGetJob._get_unset_required_fields(query_params)) - - return query_params - class _BaseListBucketOperations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -299,7 +196,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -309,22 +205,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.ListBucketOperationsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseListBucketOperations._get_unset_required_fields(query_params)) - - return query_params - class _BaseListJobs: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -335,7 +215,6 @@ def __hash__(self): # pragma: NO COVER @classmethod def _get_unset_required_fields(cls, message_dict): return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -345,23 +224,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.ListJobsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseListJobs._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetLocation: + """Base class for GetLocation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -374,19 +238,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListLocations: + """Base class for ListLocations REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -399,19 +252,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseCancelOperation: + """Base class for CancelOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -425,23 +267,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseDeleteOperation: + """Base class for DeleteOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -454,19 +281,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetOperation: + """Base class for GetOperation REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -479,19 +295,8 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListOperations: + """Base class for ListOperations REST mixin method.""" def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -504,18 +309,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseStorageBatchOperationsRestTransport', diff --git a/packages/gapic-generator/tests/unit/generator/test_generator.py b/packages/gapic-generator/tests/unit/generator/test_generator.py index 9d8545c4192f..f1566ee6e5a7 100644 --- a/packages/gapic-generator/tests/unit/generator/test_generator.py +++ b/packages/gapic-generator/tests/unit/generator/test_generator.py @@ -117,6 +117,8 @@ def test_get_response_ignores_private_files(): list_templates.return_value = [ "foo/bar/baz.py.j2", "foo/bar/_base.py.j2", + "foo/bar/__init__.py.j2", + "foo/bar/_compat.py.j2", "molluscs/squid/sample.py.j2", ] with mock.patch.object(jinja2.Environment, "get_template") as get_template: @@ -128,12 +130,13 @@ def test_get_response_ignores_private_files(): get_template.assert_has_calls( [ mock.call("molluscs/squid/sample.py.j2"), + mock.call("foo/bar/__init__.py.j2"), + mock.call("foo/bar/_compat.py.j2"), mock.call("foo/bar/baz.py.j2"), - ] + ], + any_order=True, ) - assert len(cgr.file) == 1 - assert cgr.file[0].name == "foo/bar/baz.py" - assert cgr.file[0].content == "I am a template result.\n" + assert len(cgr.file) == 3 def test_get_response_fails_invalid_file_paths():