diff --git a/packages/google-cloud-domains/docs/domains_v1/domains.rst b/packages/google-cloud-domains/docs/domains_v1/domains.rst
new file mode 100644
index 000000000000..bfb140d20b36
--- /dev/null
+++ b/packages/google-cloud-domains/docs/domains_v1/domains.rst
@@ -0,0 +1,10 @@
+Domains
+-------------------------
+
+.. automodule:: google.cloud.domains_v1.services.domains
+ :members:
+ :inherited-members:
+
+.. automodule:: google.cloud.domains_v1.services.domains.pagers
+ :members:
+ :inherited-members:
diff --git a/packages/google-cloud-domains/docs/domains_v1/services.rst b/packages/google-cloud-domains/docs/domains_v1/services.rst
new file mode 100644
index 000000000000..1073e863174d
--- /dev/null
+++ b/packages/google-cloud-domains/docs/domains_v1/services.rst
@@ -0,0 +1,6 @@
+Services for Google Cloud Domains v1 API
+========================================
+.. toctree::
+ :maxdepth: 2
+
+ domains
diff --git a/packages/google-cloud-domains/docs/domains_v1/types.rst b/packages/google-cloud-domains/docs/domains_v1/types.rst
new file mode 100644
index 000000000000..813716bbb346
--- /dev/null
+++ b/packages/google-cloud-domains/docs/domains_v1/types.rst
@@ -0,0 +1,7 @@
+Types for Google Cloud Domains v1 API
+=====================================
+
+.. automodule:: google.cloud.domains_v1.types
+ :members:
+ :undoc-members:
+ :show-inheritance:
diff --git a/packages/google-cloud-domains/docs/index.rst b/packages/google-cloud-domains/docs/index.rst
index 49850653c638..9081d62c9674 100644
--- a/packages/google-cloud-domains/docs/index.rst
+++ b/packages/google-cloud-domains/docs/index.rst
@@ -2,6 +2,9 @@
.. include:: multiprocessing.rst
+This package includes clients for multiple versions of Cloud Domains.
+By default, you will get version ``domains_v1beta1``.
+
API Reference
-------------
@@ -11,6 +14,14 @@ API Reference
domains_v1beta1/services
domains_v1beta1/types
+API Reference
+-------------
+.. toctree::
+ :maxdepth: 2
+
+ domains_v1/services
+ domains_v1/types
+
Changelog
---------
diff --git a/packages/google-cloud-domains/google/cloud/domains/__init__.py b/packages/google-cloud-domains/google/cloud/domains/__init__.py
index c65bbe7a38db..c6408e96f055 100644
--- a/packages/google-cloud-domains/google/cloud/domains/__init__.py
+++ b/packages/google-cloud-domains/google/cloud/domains/__init__.py
@@ -43,8 +43,14 @@
from google.cloud.domains_v1beta1.types.domains import (
RetrieveRegisterParametersResponse,
)
+from google.cloud.domains_v1beta1.types.domains import RetrieveTransferParametersRequest
+from google.cloud.domains_v1beta1.types.domains import (
+ RetrieveTransferParametersResponse,
+)
from google.cloud.domains_v1beta1.types.domains import SearchDomainsRequest
from google.cloud.domains_v1beta1.types.domains import SearchDomainsResponse
+from google.cloud.domains_v1beta1.types.domains import TransferDomainRequest
+from google.cloud.domains_v1beta1.types.domains import TransferParameters
from google.cloud.domains_v1beta1.types.domains import UpdateRegistrationRequest
from google.cloud.domains_v1beta1.types.domains import ContactNotice
from google.cloud.domains_v1beta1.types.domains import ContactPrivacy
@@ -74,8 +80,12 @@
"RetrieveAuthorizationCodeRequest",
"RetrieveRegisterParametersRequest",
"RetrieveRegisterParametersResponse",
+ "RetrieveTransferParametersRequest",
+ "RetrieveTransferParametersResponse",
"SearchDomainsRequest",
"SearchDomainsResponse",
+ "TransferDomainRequest",
+ "TransferParameters",
"UpdateRegistrationRequest",
"ContactNotice",
"ContactPrivacy",
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/__init__.py b/packages/google-cloud-domains/google/cloud/domains_v1/__init__.py
new file mode 100644
index 000000000000..10f29836861d
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/__init__.py
@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
+
+from .services.domains import DomainsClient
+from .services.domains import DomainsAsyncClient
+
+from .types.domains import AuthorizationCode
+from .types.domains import ConfigureContactSettingsRequest
+from .types.domains import ConfigureDnsSettingsRequest
+from .types.domains import ConfigureManagementSettingsRequest
+from .types.domains import ContactSettings
+from .types.domains import DeleteRegistrationRequest
+from .types.domains import DnsSettings
+from .types.domains import ExportRegistrationRequest
+from .types.domains import GetRegistrationRequest
+from .types.domains import ListRegistrationsRequest
+from .types.domains import ListRegistrationsResponse
+from .types.domains import ManagementSettings
+from .types.domains import OperationMetadata
+from .types.domains import RegisterDomainRequest
+from .types.domains import RegisterParameters
+from .types.domains import Registration
+from .types.domains import ResetAuthorizationCodeRequest
+from .types.domains import RetrieveAuthorizationCodeRequest
+from .types.domains import RetrieveRegisterParametersRequest
+from .types.domains import RetrieveRegisterParametersResponse
+from .types.domains import RetrieveTransferParametersRequest
+from .types.domains import RetrieveTransferParametersResponse
+from .types.domains import SearchDomainsRequest
+from .types.domains import SearchDomainsResponse
+from .types.domains import TransferDomainRequest
+from .types.domains import TransferParameters
+from .types.domains import UpdateRegistrationRequest
+from .types.domains import ContactNotice
+from .types.domains import ContactPrivacy
+from .types.domains import DomainNotice
+from .types.domains import TransferLockState
+
+__all__ = (
+ "DomainsAsyncClient",
+ "AuthorizationCode",
+ "ConfigureContactSettingsRequest",
+ "ConfigureDnsSettingsRequest",
+ "ConfigureManagementSettingsRequest",
+ "ContactNotice",
+ "ContactPrivacy",
+ "ContactSettings",
+ "DeleteRegistrationRequest",
+ "DnsSettings",
+ "DomainNotice",
+ "DomainsClient",
+ "ExportRegistrationRequest",
+ "GetRegistrationRequest",
+ "ListRegistrationsRequest",
+ "ListRegistrationsResponse",
+ "ManagementSettings",
+ "OperationMetadata",
+ "RegisterDomainRequest",
+ "RegisterParameters",
+ "Registration",
+ "ResetAuthorizationCodeRequest",
+ "RetrieveAuthorizationCodeRequest",
+ "RetrieveRegisterParametersRequest",
+ "RetrieveRegisterParametersResponse",
+ "RetrieveTransferParametersRequest",
+ "RetrieveTransferParametersResponse",
+ "SearchDomainsRequest",
+ "SearchDomainsResponse",
+ "TransferDomainRequest",
+ "TransferLockState",
+ "TransferParameters",
+ "UpdateRegistrationRequest",
+)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/gapic_metadata.json b/packages/google-cloud-domains/google/cloud/domains_v1/gapic_metadata.json
new file mode 100644
index 000000000000..c6b54de9b73a
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/gapic_metadata.json
@@ -0,0 +1,173 @@
+ {
+ "comment": "This file maps proto services/RPCs to the corresponding library clients/methods",
+ "language": "python",
+ "libraryPackage": "google.cloud.domains_v1",
+ "protoPackage": "google.cloud.domains.v1",
+ "schema": "1.0",
+ "services": {
+ "Domains": {
+ "clients": {
+ "grpc": {
+ "libraryClient": "DomainsClient",
+ "rpcs": {
+ "ConfigureContactSettings": {
+ "methods": [
+ "configure_contact_settings"
+ ]
+ },
+ "ConfigureDnsSettings": {
+ "methods": [
+ "configure_dns_settings"
+ ]
+ },
+ "ConfigureManagementSettings": {
+ "methods": [
+ "configure_management_settings"
+ ]
+ },
+ "DeleteRegistration": {
+ "methods": [
+ "delete_registration"
+ ]
+ },
+ "ExportRegistration": {
+ "methods": [
+ "export_registration"
+ ]
+ },
+ "GetRegistration": {
+ "methods": [
+ "get_registration"
+ ]
+ },
+ "ListRegistrations": {
+ "methods": [
+ "list_registrations"
+ ]
+ },
+ "RegisterDomain": {
+ "methods": [
+ "register_domain"
+ ]
+ },
+ "ResetAuthorizationCode": {
+ "methods": [
+ "reset_authorization_code"
+ ]
+ },
+ "RetrieveAuthorizationCode": {
+ "methods": [
+ "retrieve_authorization_code"
+ ]
+ },
+ "RetrieveRegisterParameters": {
+ "methods": [
+ "retrieve_register_parameters"
+ ]
+ },
+ "RetrieveTransferParameters": {
+ "methods": [
+ "retrieve_transfer_parameters"
+ ]
+ },
+ "SearchDomains": {
+ "methods": [
+ "search_domains"
+ ]
+ },
+ "TransferDomain": {
+ "methods": [
+ "transfer_domain"
+ ]
+ },
+ "UpdateRegistration": {
+ "methods": [
+ "update_registration"
+ ]
+ }
+ }
+ },
+ "grpc-async": {
+ "libraryClient": "DomainsAsyncClient",
+ "rpcs": {
+ "ConfigureContactSettings": {
+ "methods": [
+ "configure_contact_settings"
+ ]
+ },
+ "ConfigureDnsSettings": {
+ "methods": [
+ "configure_dns_settings"
+ ]
+ },
+ "ConfigureManagementSettings": {
+ "methods": [
+ "configure_management_settings"
+ ]
+ },
+ "DeleteRegistration": {
+ "methods": [
+ "delete_registration"
+ ]
+ },
+ "ExportRegistration": {
+ "methods": [
+ "export_registration"
+ ]
+ },
+ "GetRegistration": {
+ "methods": [
+ "get_registration"
+ ]
+ },
+ "ListRegistrations": {
+ "methods": [
+ "list_registrations"
+ ]
+ },
+ "RegisterDomain": {
+ "methods": [
+ "register_domain"
+ ]
+ },
+ "ResetAuthorizationCode": {
+ "methods": [
+ "reset_authorization_code"
+ ]
+ },
+ "RetrieveAuthorizationCode": {
+ "methods": [
+ "retrieve_authorization_code"
+ ]
+ },
+ "RetrieveRegisterParameters": {
+ "methods": [
+ "retrieve_register_parameters"
+ ]
+ },
+ "RetrieveTransferParameters": {
+ "methods": [
+ "retrieve_transfer_parameters"
+ ]
+ },
+ "SearchDomains": {
+ "methods": [
+ "search_domains"
+ ]
+ },
+ "TransferDomain": {
+ "methods": [
+ "transfer_domain"
+ ]
+ },
+ "UpdateRegistration": {
+ "methods": [
+ "update_registration"
+ ]
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/py.typed b/packages/google-cloud-domains/google/cloud/domains_v1/py.typed
new file mode 100644
index 000000000000..b463d6ccaf9d
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/py.typed
@@ -0,0 +1,2 @@
+# Marker file for PEP 561.
+# The google-cloud-domains package uses inline types.
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/__init__.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/__init__.py
new file mode 100644
index 000000000000..4de65971c238
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/__init__.py
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/__init__.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/__init__.py
new file mode 100644
index 000000000000..cd7bb44e5334
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/__init__.py
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
+from .client import DomainsClient
+from .async_client import DomainsAsyncClient
+
+__all__ = (
+ "DomainsClient",
+ "DomainsAsyncClient",
+)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/async_client.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/async_client.py
new file mode 100644
index 000000000000..9a293f075db4
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/async_client.py
@@ -0,0 +1,1779 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
+from collections import OrderedDict
+import functools
+import re
+from typing import Dict, Sequence, Tuple, Type, Union
+import pkg_resources
+
+import google.api_core.client_options as ClientOptions # type: ignore
+from google.api_core import exceptions as core_exceptions # type: ignore
+from google.api_core import gapic_v1 # type: ignore
+from google.api_core import retry as retries # type: ignore
+from google.auth import credentials as ga_credentials # type: ignore
+from google.oauth2 import service_account # type: ignore
+
+from google.api_core import operation # type: ignore
+from google.api_core import operation_async # type: ignore
+from google.cloud.domains_v1.services.domains import pagers
+from google.cloud.domains_v1.types import domains
+from google.protobuf import empty_pb2 # type: ignore
+from google.protobuf import field_mask_pb2 # type: ignore
+from google.protobuf import timestamp_pb2 # type: ignore
+from google.type import money_pb2 # type: ignore
+from .transports.base import DomainsTransport, DEFAULT_CLIENT_INFO
+from .transports.grpc_asyncio import DomainsGrpcAsyncIOTransport
+from .client import DomainsClient
+
+
+class DomainsAsyncClient:
+ """The Cloud Domains API enables management and configuration of
+ domain names.
+ """
+
+ _client: DomainsClient
+
+ DEFAULT_ENDPOINT = DomainsClient.DEFAULT_ENDPOINT
+ DEFAULT_MTLS_ENDPOINT = DomainsClient.DEFAULT_MTLS_ENDPOINT
+
+ registration_path = staticmethod(DomainsClient.registration_path)
+ parse_registration_path = staticmethod(DomainsClient.parse_registration_path)
+ common_billing_account_path = staticmethod(
+ DomainsClient.common_billing_account_path
+ )
+ parse_common_billing_account_path = staticmethod(
+ DomainsClient.parse_common_billing_account_path
+ )
+ common_folder_path = staticmethod(DomainsClient.common_folder_path)
+ parse_common_folder_path = staticmethod(DomainsClient.parse_common_folder_path)
+ common_organization_path = staticmethod(DomainsClient.common_organization_path)
+ parse_common_organization_path = staticmethod(
+ DomainsClient.parse_common_organization_path
+ )
+ common_project_path = staticmethod(DomainsClient.common_project_path)
+ parse_common_project_path = staticmethod(DomainsClient.parse_common_project_path)
+ common_location_path = staticmethod(DomainsClient.common_location_path)
+ parse_common_location_path = staticmethod(DomainsClient.parse_common_location_path)
+
+ @classmethod
+ def from_service_account_info(cls, info: dict, *args, **kwargs):
+ """Creates an instance of this client using the provided credentials
+ info.
+
+ Args:
+ info (dict): The service account private key info.
+ args: Additional arguments to pass to the constructor.
+ kwargs: Additional arguments to pass to the constructor.
+
+ Returns:
+ DomainsAsyncClient: The constructed client.
+ """
+ return DomainsClient.from_service_account_info.__func__(DomainsAsyncClient, info, *args, **kwargs) # type: ignore
+
+ @classmethod
+ def from_service_account_file(cls, filename: str, *args, **kwargs):
+ """Creates an instance of this client using the provided credentials
+ file.
+
+ Args:
+ filename (str): The path to the service account private key json
+ file.
+ args: Additional arguments to pass to the constructor.
+ kwargs: Additional arguments to pass to the constructor.
+
+ Returns:
+ DomainsAsyncClient: The constructed client.
+ """
+ return DomainsClient.from_service_account_file.__func__(DomainsAsyncClient, filename, *args, **kwargs) # type: ignore
+
+ from_service_account_json = from_service_account_file
+
+ @property
+ def transport(self) -> DomainsTransport:
+ """Returns the transport used by the client instance.
+
+ Returns:
+ DomainsTransport: The transport used by the client instance.
+ """
+ return self._client.transport
+
+ get_transport_class = functools.partial(
+ type(DomainsClient).get_transport_class, type(DomainsClient)
+ )
+
+ def __init__(
+ self,
+ *,
+ credentials: ga_credentials.Credentials = None,
+ transport: Union[str, DomainsTransport] = "grpc_asyncio",
+ client_options: ClientOptions = None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ ) -> None:
+ """Instantiates the domains client.
+
+ Args:
+ credentials (Optional[google.auth.credentials.Credentials]): The
+ authorization credentials to attach to requests. These
+ credentials identify the application to the service; if none
+ are specified, the client will attempt to ascertain the
+ credentials from the environment.
+ transport (Union[str, ~.DomainsTransport]): The
+ transport to use. If set to None, a transport is chosen
+ automatically.
+ client_options (ClientOptions): Custom options for the client. It
+ won't take effect if a ``transport`` instance is provided.
+ (1) The ``api_endpoint`` property can be used to override the
+ default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT
+ environment variable can also be used to override the endpoint:
+ "always" (always use the default mTLS endpoint), "never" (always
+ use the default regular endpoint) and "auto" (auto switch to the
+ default mTLS endpoint if client certificate is present, this is
+ the default value). However, the ``api_endpoint`` property takes
+ precedence if provided.
+ (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
+ is "true", then the ``client_cert_source`` property can be used
+ to provide client certificate for mutual TLS transport. If
+ not provided, the default SSL client certificate will be used if
+ present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
+ set, no client certificate will be used.
+
+ Raises:
+ google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
+ creation failed for any reason.
+ """
+ self._client = DomainsClient(
+ credentials=credentials,
+ transport=transport,
+ client_options=client_options,
+ client_info=client_info,
+ )
+
+ async def search_domains(
+ self,
+ request: domains.SearchDomainsRequest = None,
+ *,
+ location: str = None,
+ query: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.SearchDomainsResponse:
+ r"""Searches for available domain names similar to the provided
+ query.
+
+ Availability results from this method are approximate; call
+ ``RetrieveRegisterParameters`` on a domain before registering to
+ confirm availability.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.SearchDomainsRequest`):
+ The request object. Request for the `SearchDomains`
+ method.
+ location (:class:`str`):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``location`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ query (:class:`str`):
+ Required. String used to search for
+ available domain names.
+
+ This corresponds to the ``query`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.SearchDomainsResponse:
+ Response for the SearchDomains method.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([location, query])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.SearchDomainsRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if location is not None:
+ request.location = location
+ if query is not None:
+ request.query = query
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.search_domains,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ async def retrieve_register_parameters(
+ self,
+ request: domains.RetrieveRegisterParametersRequest = None,
+ *,
+ location: str = None,
+ domain_name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.RetrieveRegisterParametersResponse:
+ r"""Gets parameters needed to register a new domain name, including
+ price and up-to-date availability. Use the returned values to
+ call ``RegisterDomain``.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.RetrieveRegisterParametersRequest`):
+ The request object. Request for the
+ `RetrieveRegisterParameters` method.
+ location (:class:`str`):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``location`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ domain_name (:class:`str`):
+ Required. The domain name. Unicode
+ domain names must be expressed in
+ Punycode format.
+
+ This corresponds to the ``domain_name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.RetrieveRegisterParametersResponse:
+ Response for the RetrieveRegisterParameters method.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([location, domain_name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.RetrieveRegisterParametersRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if location is not None:
+ request.location = location
+ if domain_name is not None:
+ request.domain_name = domain_name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.retrieve_register_parameters,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ async def register_domain(
+ self,
+ request: domains.RegisterDomainRequest = None,
+ *,
+ parent: str = None,
+ registration: domains.Registration = None,
+ yearly_price: money_pb2.Money = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Registers a new domain name and creates a corresponding
+ ``Registration`` resource.
+
+ Call ``RetrieveRegisterParameters`` first to check availability
+ of the domain name and determine parameters like price that are
+ needed to build a call to this method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``REGISTRATION_PENDING``, which resolves to ``ACTIVE`` within
+ 1-2 minutes, indicating that the domain was successfully
+ registered. If the resource ends up in state
+ ``REGISTRATION_FAILED``, it indicates that the domain was not
+ registered successfully, and you can safely delete the resource
+ and retry registration.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.RegisterDomainRequest`):
+ The request object. Request for the `RegisterDomain`
+ method.
+ parent (:class:`str`):
+ Required. The parent resource of the ``Registration``.
+ Must be in the format ``projects/*/locations/*``.
+
+ This corresponds to the ``parent`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ registration (:class:`google.cloud.domains_v1.types.Registration`):
+ Required. The complete ``Registration`` resource to be
+ created.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ yearly_price (:class:`google.type.money_pb2.Money`):
+ Required. Yearly price to register or
+ renew the domain. The value that should
+ be put here can be obtained from
+ RetrieveRegisterParameters or
+ SearchDomains calls.
+
+ This corresponds to the ``yearly_price`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([parent, registration, yearly_price])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.RegisterDomainRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if parent is not None:
+ request.parent = parent
+ if registration is not None:
+ request.registration = registration
+ if yearly_price is not None:
+ request.yearly_price = yearly_price
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.register_domain,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def retrieve_transfer_parameters(
+ self,
+ request: domains.RetrieveTransferParametersRequest = None,
+ *,
+ location: str = None,
+ domain_name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.RetrieveTransferParametersResponse:
+ r"""Gets parameters needed to transfer a domain name from another
+ registrar to Cloud Domains. For domains managed by Google
+ Domains, transferring to Cloud Domains is not supported.
+
+ Use the returned values to call ``TransferDomain``.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.RetrieveTransferParametersRequest`):
+ The request object. Request for the
+ `RetrieveTransferParameters` method.
+ location (:class:`str`):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``location`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ domain_name (:class:`str`):
+ Required. The domain name. Unicode
+ domain names must be expressed in
+ Punycode format.
+
+ This corresponds to the ``domain_name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.RetrieveTransferParametersResponse:
+ Response for the RetrieveTransferParameters method.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([location, domain_name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.RetrieveTransferParametersRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if location is not None:
+ request.location = location
+ if domain_name is not None:
+ request.domain_name = domain_name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.retrieve_transfer_parameters,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ async def transfer_domain(
+ self,
+ request: domains.TransferDomainRequest = None,
+ *,
+ parent: str = None,
+ registration: domains.Registration = None,
+ yearly_price: money_pb2.Money = None,
+ authorization_code: domains.AuthorizationCode = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Transfers a domain name from another registrar to Cloud Domains.
+ For domains managed by Google Domains, transferring to Cloud
+ Domains is not supported.
+
+ Before calling this method, go to the domain's current registrar
+ to unlock the domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to this
+ method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``TRANSFER_PENDING``. It can take several days to complete the
+ transfer process. The registrant can often speed up this process
+ by approving the transfer through the current registrar, either
+ by clicking a link in an email from the registrar or by visiting
+ the registrar's website.
+
+ A few minutes after transfer approval, the resource transitions
+ to state ``ACTIVE``, indicating that the transfer was
+ successful. If the transfer is rejected or the request expires
+ without being approved, the resource can end up in state
+ ``TRANSFER_FAILED``. If transfer fails, you can safely delete
+ the resource and retry the transfer.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.TransferDomainRequest`):
+ The request object. Request for the `TransferDomain`
+ method.
+ parent (:class:`str`):
+ Required. The parent resource of the ``Registration``.
+ Must be in the format ``projects/*/locations/*``.
+
+ This corresponds to the ``parent`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ registration (:class:`google.cloud.domains_v1.types.Registration`):
+ Required. The complete ``Registration`` resource to be
+ created.
+
+ You can leave ``registration.dns_settings`` unset to
+ import the domain's current DNS configuration from its
+ current registrar. Use this option only if you are sure
+ that the domain's current DNS service does not cease
+ upon transfer, as is often the case for DNS services
+ provided for free by the registrar.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ yearly_price (:class:`google.type.money_pb2.Money`):
+ Required. Acknowledgement of the price to transfer or
+ renew the domain for one year. Call
+ ``RetrieveTransferParameters`` to obtain the price,
+ which you must acknowledge.
+
+ This corresponds to the ``yearly_price`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ authorization_code (:class:`google.cloud.domains_v1.types.AuthorizationCode`):
+ The domain's transfer authorization
+ code. You can obtain this from the
+ domain's current registrar.
+
+ This corresponds to the ``authorization_code`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any(
+ [parent, registration, yearly_price, authorization_code]
+ )
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.TransferDomainRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if parent is not None:
+ request.parent = parent
+ if registration is not None:
+ request.registration = registration
+ if yearly_price is not None:
+ request.yearly_price = yearly_price
+ if authorization_code is not None:
+ request.authorization_code = authorization_code
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.transfer_domain,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def list_registrations(
+ self,
+ request: domains.ListRegistrationsRequest = None,
+ *,
+ parent: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> pagers.ListRegistrationsAsyncPager:
+ r"""Lists the ``Registration`` resources in a project.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.ListRegistrationsRequest`):
+ The request object. Request for the `ListRegistrations`
+ method.
+ parent (:class:`str`):
+ Required. The project and location from which to list
+ ``Registration``\ s, specified in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``parent`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.services.domains.pagers.ListRegistrationsAsyncPager:
+ Response for the ListRegistrations method.
+
+ Iterating over this object will yield results and
+ resolve additional pages automatically.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([parent])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.ListRegistrationsRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if parent is not None:
+ request.parent = parent
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.list_registrations,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # This method is paged; wrap the response in a pager, which provides
+ # an `__aiter__` convenience method.
+ response = pagers.ListRegistrationsAsyncPager(
+ method=rpc, request=request, response=response, metadata=metadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def get_registration(
+ self,
+ request: domains.GetRegistrationRequest = None,
+ *,
+ name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.Registration:
+ r"""Gets the details of a ``Registration`` resource.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.GetRegistrationRequest`):
+ The request object. Request for the `GetRegistration`
+ method.
+ name (:class:`str`):
+ Required. The name of the ``Registration`` to get, in
+ the format ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.Registration:
+ The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.GetRegistrationRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if name is not None:
+ request.name = name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.get_registration,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ async def update_registration(
+ self,
+ request: domains.UpdateRegistrationRequest = None,
+ *,
+ registration: domains.Registration = None,
+ update_mask: field_mask_pb2.FieldMask = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Updates select fields of a ``Registration`` resource, notably
+ ``labels``. To update other fields, use the appropriate custom
+ update method:
+
+ - To update management settings, see
+ ``ConfigureManagementSettings``
+ - To update DNS configuration, see ``ConfigureDnsSettings``
+ - To update contact information, see
+ ``ConfigureContactSettings``
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.UpdateRegistrationRequest`):
+ The request object. Request for the `UpdateRegistration`
+ method.
+ registration (:class:`google.cloud.domains_v1.types.Registration`):
+ Fields of the ``Registration`` to update.
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`):
+ Required. The field mask describing which fields to
+ update as a comma-separated list. For example, if only
+ the labels are being updated, the ``update_mask`` is
+ ``"labels"``.
+
+ This corresponds to the ``update_mask`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration, update_mask])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.UpdateRegistrationRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+ if update_mask is not None:
+ request.update_mask = update_mask
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.update_registration,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration.name", request.registration.name),)
+ ),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def configure_management_settings(
+ self,
+ request: domains.ConfigureManagementSettingsRequest = None,
+ *,
+ registration: str = None,
+ management_settings: domains.ManagementSettings = None,
+ update_mask: field_mask_pb2.FieldMask = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Updates a ``Registration``'s management settings.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.ConfigureManagementSettingsRequest`):
+ The request object. Request for the
+ `ConfigureManagementSettings` method.
+ registration (:class:`str`):
+ Required. The name of the ``Registration`` whose
+ management settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ management_settings (:class:`google.cloud.domains_v1.types.ManagementSettings`):
+ Fields of the ``ManagementSettings`` to update.
+ This corresponds to the ``management_settings`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`):
+ Required. The field mask describing which fields to
+ update as a comma-separated list. For example, if only
+ the transfer lock is being updated, the ``update_mask``
+ is ``"transfer_lock_state"``.
+
+ This corresponds to the ``update_mask`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration, management_settings, update_mask])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.ConfigureManagementSettingsRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+ if management_settings is not None:
+ request.management_settings = management_settings
+ if update_mask is not None:
+ request.update_mask = update_mask
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.configure_management_settings,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def configure_dns_settings(
+ self,
+ request: domains.ConfigureDnsSettingsRequest = None,
+ *,
+ registration: str = None,
+ dns_settings: domains.DnsSettings = None,
+ update_mask: field_mask_pb2.FieldMask = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Updates a ``Registration``'s DNS settings.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.ConfigureDnsSettingsRequest`):
+ The request object. Request for the
+ `ConfigureDnsSettings` method.
+ registration (:class:`str`):
+ Required. The name of the ``Registration`` whose DNS
+ settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ dns_settings (:class:`google.cloud.domains_v1.types.DnsSettings`):
+ Fields of the ``DnsSettings`` to update.
+ This corresponds to the ``dns_settings`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`):
+ Required. The field mask describing which fields to
+ update as a comma-separated list. For example, if only
+ the name servers are being updated for an existing
+ Custom DNS configuration, the ``update_mask`` is
+ ``"custom_dns.name_servers"``.
+
+ When changing the DNS provider from one type to another,
+ pass the new provider's field name as part of the field
+ mask. For example, when changing from a Google Domains
+ DNS configuration to a Custom DNS configuration, the
+ ``update_mask`` is ``"custom_dns"``. //
+
+ This corresponds to the ``update_mask`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration, dns_settings, update_mask])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.ConfigureDnsSettingsRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+ if dns_settings is not None:
+ request.dns_settings = dns_settings
+ if update_mask is not None:
+ request.update_mask = update_mask
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.configure_dns_settings,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def configure_contact_settings(
+ self,
+ request: domains.ConfigureContactSettingsRequest = None,
+ *,
+ registration: str = None,
+ contact_settings: domains.ContactSettings = None,
+ update_mask: field_mask_pb2.FieldMask = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Updates a ``Registration``'s contact settings. Some changes
+ require confirmation by the domain's registrant contact .
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.ConfigureContactSettingsRequest`):
+ The request object. Request for the
+ `ConfigureContactSettings` method.
+ registration (:class:`str`):
+ Required. The name of the ``Registration`` whose contact
+ settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ contact_settings (:class:`google.cloud.domains_v1.types.ContactSettings`):
+ Fields of the ``ContactSettings`` to update.
+ This corresponds to the ``contact_settings`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`):
+ Required. The field mask describing which fields to
+ update as a comma-separated list. For example, if only
+ the registrant contact is being updated, the
+ ``update_mask`` is ``"registrant_contact"``.
+
+ This corresponds to the ``update_mask`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration, contact_settings, update_mask])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.ConfigureContactSettingsRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+ if contact_settings is not None:
+ request.contact_settings = contact_settings
+ if update_mask is not None:
+ request.update_mask = update_mask
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.configure_contact_settings,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def export_registration(
+ self,
+ request: domains.ExportRegistrationRequest = None,
+ *,
+ name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Exports a ``Registration`` resource, such that it is no longer
+ managed by Cloud Domains.
+
+ When an active domain is successfully exported, you can continue
+ to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.ExportRegistrationRequest`):
+ The request object. Request for the `ExportRegistration`
+ method.
+ name (:class:`str`):
+ Required. The name of the ``Registration`` to export, in
+ the format ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.ExportRegistrationRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if name is not None:
+ request.name = name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.export_registration,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def delete_registration(
+ self,
+ request: domains.DeleteRegistrationRequest = None,
+ *,
+ name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Deletes a ``Registration`` resource.
+
+ This method works on any ``Registration`` resource using
+ `Subscription or Commitment
+ billing </domains/pricing#billing-models>`__, provided that the
+ resource was created at least 1 day in the past.
+
+ For ``Registration`` resources using `Monthly
+ billing </domains/pricing#billing-models>`__, this method works
+ if:
+
+ - ``state`` is ``EXPORTED`` with ``expire_time`` in the past
+ - ``state`` is ``REGISTRATION_FAILED``
+ - ``state`` is ``TRANSFER_FAILED``
+
+ When an active registration is successfully deleted, you can
+ continue to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.DeleteRegistrationRequest`):
+ The request object. Request for the `DeleteRegistration`
+ method.
+ name (:class:`str`):
+ Required. The name of the ``Registration`` to delete, in
+ the format ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.protobuf.empty_pb2.Empty` A generic empty message that you can re-use to avoid defining duplicated
+ empty messages in your APIs. A typical example is to
+ use it as the request or the response type of an API
+ method. For instance:
+
+ service Foo {
+ rpc Bar(google.protobuf.Empty) returns
+ (google.protobuf.Empty);
+
+ }
+
+ The JSON representation for Empty is empty JSON
+ object {}.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.DeleteRegistrationRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if name is not None:
+ request.name = name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.delete_registration,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ empty_pb2.Empty,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ async def retrieve_authorization_code(
+ self,
+ request: domains.RetrieveAuthorizationCodeRequest = None,
+ *,
+ registration: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.AuthorizationCode:
+ r"""Gets the authorization code of the ``Registration`` for the
+ purpose of transferring the domain to another registrar.
+
+ You can call this method only after 60 days have elapsed since
+ the initial domain registration.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.RetrieveAuthorizationCodeRequest`):
+ The request object. Request for the
+ `RetrieveAuthorizationCode` method.
+ registration (:class:`str`):
+ Required. The name of the ``Registration`` whose
+ authorization code is being retrieved, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.AuthorizationCode:
+ Defines an authorization code.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.RetrieveAuthorizationCodeRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.retrieve_authorization_code,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ async def reset_authorization_code(
+ self,
+ request: domains.ResetAuthorizationCodeRequest = None,
+ *,
+ registration: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.AuthorizationCode:
+ r"""Resets the authorization code of the ``Registration`` to a new
+ random string.
+
+ You can call this method only after 60 days have elapsed since
+ the initial domain registration.
+
+ Args:
+ request (:class:`google.cloud.domains_v1.types.ResetAuthorizationCodeRequest`):
+ The request object. Request for the
+ `ResetAuthorizationCode` method.
+ registration (:class:`str`):
+ Required. The name of the ``Registration`` whose
+ authorization code is being reset, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.AuthorizationCode:
+ Defines an authorization code.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.ResetAuthorizationCodeRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.reset_authorization_code,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ async def __aenter__(self):
+ return self
+
+ async def __aexit__(self, exc_type, exc, tb):
+ await self.transport.close()
+
+
+try:
+ DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+ gapic_version=pkg_resources.get_distribution("google-cloud-domains",).version,
+ )
+except pkg_resources.DistributionNotFound:
+ DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo()
+
+
+__all__ = ("DomainsAsyncClient",)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/client.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/client.py
new file mode 100644
index 000000000000..6774df5088f7
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/client.py
@@ -0,0 +1,1988 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
+from collections import OrderedDict
+from distutils import util
+import os
+import re
+from typing import Dict, Optional, Sequence, Tuple, Type, Union
+import pkg_resources
+
+from google.api_core import client_options as client_options_lib # type: ignore
+from google.api_core import exceptions as core_exceptions # type: ignore
+from google.api_core import gapic_v1 # type: ignore
+from google.api_core import retry as retries # type: ignore
+from google.auth import credentials as ga_credentials # type: ignore
+from google.auth.transport import mtls # type: ignore
+from google.auth.transport.grpc import SslCredentials # type: ignore
+from google.auth.exceptions import MutualTLSChannelError # type: ignore
+from google.oauth2 import service_account # type: ignore
+
+from google.api_core import operation # type: ignore
+from google.api_core import operation_async # type: ignore
+from google.cloud.domains_v1.services.domains import pagers
+from google.cloud.domains_v1.types import domains
+from google.protobuf import empty_pb2 # type: ignore
+from google.protobuf import field_mask_pb2 # type: ignore
+from google.protobuf import timestamp_pb2 # type: ignore
+from google.type import money_pb2 # type: ignore
+from .transports.base import DomainsTransport, DEFAULT_CLIENT_INFO
+from .transports.grpc import DomainsGrpcTransport
+from .transports.grpc_asyncio import DomainsGrpcAsyncIOTransport
+
+
+class DomainsClientMeta(type):
+ """Metaclass for the Domains client.
+
+ This provides class-level methods for building and retrieving
+ support objects (e.g. transport) without polluting the client instance
+ objects.
+ """
+
+ _transport_registry = OrderedDict() # type: Dict[str, Type[DomainsTransport]]
+ _transport_registry["grpc"] = DomainsGrpcTransport
+ _transport_registry["grpc_asyncio"] = DomainsGrpcAsyncIOTransport
+
+ def get_transport_class(cls, label: str = None,) -> Type[DomainsTransport]:
+ """Returns an appropriate transport class.
+
+ Args:
+ label: The name of the desired transport. If none is
+ provided, then the first transport in the registry is used.
+
+ Returns:
+ The transport class to use.
+ """
+ # If a specific transport is requested, return that one.
+ if label:
+ return cls._transport_registry[label]
+
+ # No transport is requested; return the default (that is, the first one
+ # in the dictionary).
+ return next(iter(cls._transport_registry.values()))
+
+
+class DomainsClient(metaclass=DomainsClientMeta):
+ """The Cloud Domains API enables management and configuration of
+ domain names.
+ """
+
+ @staticmethod
+ def _get_default_mtls_endpoint(api_endpoint):
+ """Converts api endpoint to mTLS endpoint.
+
+ Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to
+ "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively.
+ Args:
+ api_endpoint (Optional[str]): the api endpoint to convert.
+ Returns:
+ str: converted mTLS api endpoint.
+ """
+ if not api_endpoint:
+ return api_endpoint
+
+ mtls_endpoint_re = re.compile(
+ r"(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?"
+ )
+
+ m = mtls_endpoint_re.match(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")
+
+ DEFAULT_ENDPOINT = "domains.googleapis.com"
+ DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__( # type: ignore
+ DEFAULT_ENDPOINT
+ )
+
+ @classmethod
+ def from_service_account_info(cls, info: dict, *args, **kwargs):
+ """Creates an instance of this client using the provided credentials
+ info.
+
+ Args:
+ info (dict): The service account private key info.
+ args: Additional arguments to pass to the constructor.
+ kwargs: Additional arguments to pass to the constructor.
+
+ Returns:
+ DomainsClient: The constructed client.
+ """
+ credentials = service_account.Credentials.from_service_account_info(info)
+ kwargs["credentials"] = credentials
+ return cls(*args, **kwargs)
+
+ @classmethod
+ def from_service_account_file(cls, filename: str, *args, **kwargs):
+ """Creates an instance of this client using the provided credentials
+ file.
+
+ Args:
+ filename (str): The path to the service account private key json
+ file.
+ args: Additional arguments to pass to the constructor.
+ kwargs: Additional arguments to pass to the constructor.
+
+ Returns:
+ DomainsClient: The constructed client.
+ """
+ credentials = service_account.Credentials.from_service_account_file(filename)
+ kwargs["credentials"] = credentials
+ return cls(*args, **kwargs)
+
+ from_service_account_json = from_service_account_file
+
+ @property
+ def transport(self) -> DomainsTransport:
+ """Returns the transport used by the client instance.
+
+ Returns:
+ DomainsTransport: The transport used by the client
+ instance.
+ """
+ return self._transport
+
+ @staticmethod
+ def registration_path(project: str, location: str, registration: str,) -> str:
+ """Returns a fully-qualified registration string."""
+ return "projects/{project}/locations/{location}/registrations/{registration}".format(
+ project=project, location=location, registration=registration,
+ )
+
+ @staticmethod
+ def parse_registration_path(path: str) -> Dict[str, str]:
+ """Parses a registration path into its component segments."""
+ m = re.match(
+ r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/registrations/(?P<registration>.+?)$",
+ path,
+ )
+ return m.groupdict() if m else {}
+
+ @staticmethod
+ def common_billing_account_path(billing_account: str,) -> str:
+ """Returns a fully-qualified billing_account string."""
+ return "billingAccounts/{billing_account}".format(
+ billing_account=billing_account,
+ )
+
+ @staticmethod
+ def parse_common_billing_account_path(path: str) -> Dict[str, str]:
+ """Parse a billing_account path into its component segments."""
+ m = re.match(r"^billingAccounts/(?P<billing_account>.+?)$", path)
+ return m.groupdict() if m else {}
+
+ @staticmethod
+ def common_folder_path(folder: str,) -> str:
+ """Returns a fully-qualified folder string."""
+ return "folders/{folder}".format(folder=folder,)
+
+ @staticmethod
+ def parse_common_folder_path(path: str) -> Dict[str, str]:
+ """Parse a folder path into its component segments."""
+ m = re.match(r"^folders/(?P<folder>.+?)$", path)
+ return m.groupdict() if m else {}
+
+ @staticmethod
+ def common_organization_path(organization: str,) -> str:
+ """Returns a fully-qualified organization string."""
+ return "organizations/{organization}".format(organization=organization,)
+
+ @staticmethod
+ def parse_common_organization_path(path: str) -> Dict[str, str]:
+ """Parse a organization path into its component segments."""
+ m = re.match(r"^organizations/(?P<organization>.+?)$", path)
+ return m.groupdict() if m else {}
+
+ @staticmethod
+ def common_project_path(project: str,) -> str:
+ """Returns a fully-qualified project string."""
+ return "projects/{project}".format(project=project,)
+
+ @staticmethod
+ def parse_common_project_path(path: str) -> Dict[str, str]:
+ """Parse a project path into its component segments."""
+ m = re.match(r"^projects/(?P<project>.+?)$", path)
+ return m.groupdict() if m else {}
+
+ @staticmethod
+ def common_location_path(project: str, location: str,) -> str:
+ """Returns a fully-qualified location string."""
+ return "projects/{project}/locations/{location}".format(
+ project=project, location=location,
+ )
+
+ @staticmethod
+ def parse_common_location_path(path: str) -> Dict[str, str]:
+ """Parse a location path into its component segments."""
+ m = re.match(r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)$", path)
+ return m.groupdict() if m else {}
+
+ def __init__(
+ self,
+ *,
+ credentials: Optional[ga_credentials.Credentials] = None,
+ transport: Union[str, DomainsTransport, None] = None,
+ client_options: Optional[client_options_lib.ClientOptions] = None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ ) -> None:
+ """Instantiates the domains client.
+
+ Args:
+ credentials (Optional[google.auth.credentials.Credentials]): The
+ authorization credentials to attach to requests. These
+ credentials identify the application to the service; if none
+ are specified, the client will attempt to ascertain the
+ credentials from the environment.
+ transport (Union[str, DomainsTransport]): The
+ transport to use. If set to None, a transport is chosen
+ automatically.
+ client_options (google.api_core.client_options.ClientOptions): Custom options for the
+ client. It won't take effect if a ``transport`` instance is provided.
+ (1) The ``api_endpoint`` property can be used to override the
+ default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT
+ environment variable can also be used to override the endpoint:
+ "always" (always use the default mTLS endpoint), "never" (always
+ use the default regular endpoint) and "auto" (auto switch to the
+ default mTLS endpoint if client certificate is present, this is
+ the default value). However, the ``api_endpoint`` property takes
+ precedence if provided.
+ (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
+ is "true", then the ``client_cert_source`` property can be used
+ to provide client certificate for mutual TLS transport. If
+ not provided, the default SSL client certificate will be used if
+ present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
+ set, no client certificate will be used.
+ client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+ The client info used to send a user-agent string along with
+ API requests. If ``None``, then default info will be used.
+ Generally, you only need to set this if you're developing
+ your own client library.
+
+ Raises:
+ google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
+ creation failed for any reason.
+ """
+ if isinstance(client_options, dict):
+ client_options = client_options_lib.from_dict(client_options)
+ if client_options is None:
+ client_options = client_options_lib.ClientOptions()
+
+ # Create SSL credentials for mutual TLS if needed.
+ use_client_cert = bool(
+ util.strtobool(os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false"))
+ )
+
+ client_cert_source_func = None
+ is_mtls = False
+ if use_client_cert:
+ if client_options.client_cert_source:
+ is_mtls = True
+ client_cert_source_func = client_options.client_cert_source
+ else:
+ is_mtls = mtls.has_default_client_cert_source()
+ if is_mtls:
+ client_cert_source_func = mtls.default_client_cert_source()
+ else:
+ client_cert_source_func = None
+
+ # Figure out which api endpoint to use.
+ if client_options.api_endpoint is not None:
+ api_endpoint = client_options.api_endpoint
+ else:
+ use_mtls_env = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto")
+ if use_mtls_env == "never":
+ api_endpoint = self.DEFAULT_ENDPOINT
+ elif use_mtls_env == "always":
+ api_endpoint = self.DEFAULT_MTLS_ENDPOINT
+ elif use_mtls_env == "auto":
+ if is_mtls:
+ api_endpoint = self.DEFAULT_MTLS_ENDPOINT
+ else:
+ api_endpoint = self.DEFAULT_ENDPOINT
+ else:
+ raise MutualTLSChannelError(
+ "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted "
+ "values: never, auto, always"
+ )
+
+ # Save or instantiate the transport.
+ # Ordinarily, we provide the transport, but allowing a custom transport
+ # instance provides an extensibility point for unusual situations.
+ if isinstance(transport, DomainsTransport):
+ # transport is a DomainsTransport instance.
+ if credentials or client_options.credentials_file:
+ raise ValueError(
+ "When providing a transport instance, "
+ "provide its credentials directly."
+ )
+ if client_options.scopes:
+ raise ValueError(
+ "When providing a transport instance, provide its scopes "
+ "directly."
+ )
+ self._transport = transport
+ else:
+ Transport = type(self).get_transport_class(transport)
+ self._transport = Transport(
+ credentials=credentials,
+ credentials_file=client_options.credentials_file,
+ host=api_endpoint,
+ scopes=client_options.scopes,
+ client_cert_source_for_mtls=client_cert_source_func,
+ quota_project_id=client_options.quota_project_id,
+ client_info=client_info,
+ always_use_jwt_access=True,
+ )
+
+ def search_domains(
+ self,
+ request: Union[domains.SearchDomainsRequest, dict] = None,
+ *,
+ location: str = None,
+ query: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.SearchDomainsResponse:
+ r"""Searches for available domain names similar to the provided
+ query.
+
+ Availability results from this method are approximate; call
+ ``RetrieveRegisterParameters`` on a domain before registering to
+ confirm availability.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.SearchDomainsRequest, dict]):
+ The request object. Request for the `SearchDomains`
+ method.
+ location (str):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``location`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ query (str):
+ Required. String used to search for
+ available domain names.
+
+ This corresponds to the ``query`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.SearchDomainsResponse:
+ Response for the SearchDomains method.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([location, query])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.SearchDomainsRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.SearchDomainsRequest):
+ request = domains.SearchDomainsRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if location is not None:
+ request.location = location
+ if query is not None:
+ request.query = query
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.search_domains]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ def retrieve_register_parameters(
+ self,
+ request: Union[domains.RetrieveRegisterParametersRequest, dict] = None,
+ *,
+ location: str = None,
+ domain_name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.RetrieveRegisterParametersResponse:
+ r"""Gets parameters needed to register a new domain name, including
+ price and up-to-date availability. Use the returned values to
+ call ``RegisterDomain``.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.RetrieveRegisterParametersRequest, dict]):
+ The request object. Request for the
+ `RetrieveRegisterParameters` method.
+ location (str):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``location`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ domain_name (str):
+ Required. The domain name. Unicode
+ domain names must be expressed in
+ Punycode format.
+
+ This corresponds to the ``domain_name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.RetrieveRegisterParametersResponse:
+ Response for the RetrieveRegisterParameters method.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([location, domain_name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.RetrieveRegisterParametersRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.RetrieveRegisterParametersRequest):
+ request = domains.RetrieveRegisterParametersRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if location is not None:
+ request.location = location
+ if domain_name is not None:
+ request.domain_name = domain_name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[
+ self._transport.retrieve_register_parameters
+ ]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ def register_domain(
+ self,
+ request: Union[domains.RegisterDomainRequest, dict] = None,
+ *,
+ parent: str = None,
+ registration: domains.Registration = None,
+ yearly_price: money_pb2.Money = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Registers a new domain name and creates a corresponding
+ ``Registration`` resource.
+
+ Call ``RetrieveRegisterParameters`` first to check availability
+ of the domain name and determine parameters like price that are
+ needed to build a call to this method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``REGISTRATION_PENDING``, which resolves to ``ACTIVE`` within
+ 1-2 minutes, indicating that the domain was successfully
+ registered. If the resource ends up in state
+ ``REGISTRATION_FAILED``, it indicates that the domain was not
+ registered successfully, and you can safely delete the resource
+ and retry registration.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.RegisterDomainRequest, dict]):
+ The request object. Request for the `RegisterDomain`
+ method.
+ parent (str):
+ Required. The parent resource of the ``Registration``.
+ Must be in the format ``projects/*/locations/*``.
+
+ This corresponds to the ``parent`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ registration (google.cloud.domains_v1.types.Registration):
+ Required. The complete ``Registration`` resource to be
+ created.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ yearly_price (google.type.money_pb2.Money):
+ Required. Yearly price to register or
+ renew the domain. The value that should
+ be put here can be obtained from
+ RetrieveRegisterParameters or
+ SearchDomains calls.
+
+ This corresponds to the ``yearly_price`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([parent, registration, yearly_price])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.RegisterDomainRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.RegisterDomainRequest):
+ request = domains.RegisterDomainRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if parent is not None:
+ request.parent = parent
+ if registration is not None:
+ request.registration = registration
+ if yearly_price is not None:
+ request.yearly_price = yearly_price
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.register_domain]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def retrieve_transfer_parameters(
+ self,
+ request: Union[domains.RetrieveTransferParametersRequest, dict] = None,
+ *,
+ location: str = None,
+ domain_name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.RetrieveTransferParametersResponse:
+ r"""Gets parameters needed to transfer a domain name from another
+ registrar to Cloud Domains. For domains managed by Google
+ Domains, transferring to Cloud Domains is not supported.
+
+ Use the returned values to call ``TransferDomain``.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.RetrieveTransferParametersRequest, dict]):
+ The request object. Request for the
+ `RetrieveTransferParameters` method.
+ location (str):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``location`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ domain_name (str):
+ Required. The domain name. Unicode
+ domain names must be expressed in
+ Punycode format.
+
+ This corresponds to the ``domain_name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.RetrieveTransferParametersResponse:
+ Response for the RetrieveTransferParameters method.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([location, domain_name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.RetrieveTransferParametersRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.RetrieveTransferParametersRequest):
+ request = domains.RetrieveTransferParametersRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if location is not None:
+ request.location = location
+ if domain_name is not None:
+ request.domain_name = domain_name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[
+ self._transport.retrieve_transfer_parameters
+ ]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ def transfer_domain(
+ self,
+ request: Union[domains.TransferDomainRequest, dict] = None,
+ *,
+ parent: str = None,
+ registration: domains.Registration = None,
+ yearly_price: money_pb2.Money = None,
+ authorization_code: domains.AuthorizationCode = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Transfers a domain name from another registrar to Cloud Domains.
+ For domains managed by Google Domains, transferring to Cloud
+ Domains is not supported.
+
+ Before calling this method, go to the domain's current registrar
+ to unlock the domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to this
+ method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``TRANSFER_PENDING``. It can take several days to complete the
+ transfer process. The registrant can often speed up this process
+ by approving the transfer through the current registrar, either
+ by clicking a link in an email from the registrar or by visiting
+ the registrar's website.
+
+ A few minutes after transfer approval, the resource transitions
+ to state ``ACTIVE``, indicating that the transfer was
+ successful. If the transfer is rejected or the request expires
+ without being approved, the resource can end up in state
+ ``TRANSFER_FAILED``. If transfer fails, you can safely delete
+ the resource and retry the transfer.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.TransferDomainRequest, dict]):
+ The request object. Request for the `TransferDomain`
+ method.
+ parent (str):
+ Required. The parent resource of the ``Registration``.
+ Must be in the format ``projects/*/locations/*``.
+
+ This corresponds to the ``parent`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ registration (google.cloud.domains_v1.types.Registration):
+ Required. The complete ``Registration`` resource to be
+ created.
+
+ You can leave ``registration.dns_settings`` unset to
+ import the domain's current DNS configuration from its
+ current registrar. Use this option only if you are sure
+ that the domain's current DNS service does not cease
+ upon transfer, as is often the case for DNS services
+ provided for free by the registrar.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ yearly_price (google.type.money_pb2.Money):
+ Required. Acknowledgement of the price to transfer or
+ renew the domain for one year. Call
+ ``RetrieveTransferParameters`` to obtain the price,
+ which you must acknowledge.
+
+ This corresponds to the ``yearly_price`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ authorization_code (google.cloud.domains_v1.types.AuthorizationCode):
+ The domain's transfer authorization
+ code. You can obtain this from the
+ domain's current registrar.
+
+ This corresponds to the ``authorization_code`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any(
+ [parent, registration, yearly_price, authorization_code]
+ )
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.TransferDomainRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.TransferDomainRequest):
+ request = domains.TransferDomainRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if parent is not None:
+ request.parent = parent
+ if registration is not None:
+ request.registration = registration
+ if yearly_price is not None:
+ request.yearly_price = yearly_price
+ if authorization_code is not None:
+ request.authorization_code = authorization_code
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.transfer_domain]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def list_registrations(
+ self,
+ request: Union[domains.ListRegistrationsRequest, dict] = None,
+ *,
+ parent: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> pagers.ListRegistrationsPager:
+ r"""Lists the ``Registration`` resources in a project.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.ListRegistrationsRequest, dict]):
+ The request object. Request for the `ListRegistrations`
+ method.
+ parent (str):
+ Required. The project and location from which to list
+ ``Registration``\ s, specified in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``parent`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.services.domains.pagers.ListRegistrationsPager:
+ Response for the ListRegistrations method.
+
+ Iterating over this object will yield results and
+ resolve additional pages automatically.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([parent])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.ListRegistrationsRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.ListRegistrationsRequest):
+ request = domains.ListRegistrationsRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if parent is not None:
+ request.parent = parent
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.list_registrations]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # This method is paged; wrap the response in a pager, which provides
+ # an `__iter__` convenience method.
+ response = pagers.ListRegistrationsPager(
+ method=rpc, request=request, response=response, metadata=metadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def get_registration(
+ self,
+ request: Union[domains.GetRegistrationRequest, dict] = None,
+ *,
+ name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.Registration:
+ r"""Gets the details of a ``Registration`` resource.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.GetRegistrationRequest, dict]):
+ The request object. Request for the `GetRegistration`
+ method.
+ name (str):
+ Required. The name of the ``Registration`` to get, in
+ the format ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.Registration:
+ The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.GetRegistrationRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.GetRegistrationRequest):
+ request = domains.GetRegistrationRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if name is not None:
+ request.name = name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.get_registration]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ def update_registration(
+ self,
+ request: Union[domains.UpdateRegistrationRequest, dict] = None,
+ *,
+ registration: domains.Registration = None,
+ update_mask: field_mask_pb2.FieldMask = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Updates select fields of a ``Registration`` resource, notably
+ ``labels``. To update other fields, use the appropriate custom
+ update method:
+
+ - To update management settings, see
+ ``ConfigureManagementSettings``
+ - To update DNS configuration, see ``ConfigureDnsSettings``
+ - To update contact information, see
+ ``ConfigureContactSettings``
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.UpdateRegistrationRequest, dict]):
+ The request object. Request for the `UpdateRegistration`
+ method.
+ registration (google.cloud.domains_v1.types.Registration):
+ Fields of the ``Registration`` to update.
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ update_mask (google.protobuf.field_mask_pb2.FieldMask):
+ Required. The field mask describing which fields to
+ update as a comma-separated list. For example, if only
+ the labels are being updated, the ``update_mask`` is
+ ``"labels"``.
+
+ This corresponds to the ``update_mask`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration, update_mask])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.UpdateRegistrationRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.UpdateRegistrationRequest):
+ request = domains.UpdateRegistrationRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+ if update_mask is not None:
+ request.update_mask = update_mask
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.update_registration]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration.name", request.registration.name),)
+ ),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def configure_management_settings(
+ self,
+ request: Union[domains.ConfigureManagementSettingsRequest, dict] = None,
+ *,
+ registration: str = None,
+ management_settings: domains.ManagementSettings = None,
+ update_mask: field_mask_pb2.FieldMask = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Updates a ``Registration``'s management settings.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.ConfigureManagementSettingsRequest, dict]):
+ The request object. Request for the
+ `ConfigureManagementSettings` method.
+ registration (str):
+ Required. The name of the ``Registration`` whose
+ management settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ management_settings (google.cloud.domains_v1.types.ManagementSettings):
+ Fields of the ``ManagementSettings`` to update.
+ This corresponds to the ``management_settings`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ update_mask (google.protobuf.field_mask_pb2.FieldMask):
+ Required. The field mask describing which fields to
+ update as a comma-separated list. For example, if only
+ the transfer lock is being updated, the ``update_mask``
+ is ``"transfer_lock_state"``.
+
+ This corresponds to the ``update_mask`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration, management_settings, update_mask])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.ConfigureManagementSettingsRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.ConfigureManagementSettingsRequest):
+ request = domains.ConfigureManagementSettingsRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+ if management_settings is not None:
+ request.management_settings = management_settings
+ if update_mask is not None:
+ request.update_mask = update_mask
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[
+ self._transport.configure_management_settings
+ ]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def configure_dns_settings(
+ self,
+ request: Union[domains.ConfigureDnsSettingsRequest, dict] = None,
+ *,
+ registration: str = None,
+ dns_settings: domains.DnsSettings = None,
+ update_mask: field_mask_pb2.FieldMask = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Updates a ``Registration``'s DNS settings.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.ConfigureDnsSettingsRequest, dict]):
+ The request object. Request for the
+ `ConfigureDnsSettings` method.
+ registration (str):
+ Required. The name of the ``Registration`` whose DNS
+ settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ dns_settings (google.cloud.domains_v1.types.DnsSettings):
+ Fields of the ``DnsSettings`` to update.
+ This corresponds to the ``dns_settings`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ update_mask (google.protobuf.field_mask_pb2.FieldMask):
+ Required. The field mask describing which fields to
+ update as a comma-separated list. For example, if only
+ the name servers are being updated for an existing
+ Custom DNS configuration, the ``update_mask`` is
+ ``"custom_dns.name_servers"``.
+
+ When changing the DNS provider from one type to another,
+ pass the new provider's field name as part of the field
+ mask. For example, when changing from a Google Domains
+ DNS configuration to a Custom DNS configuration, the
+ ``update_mask`` is ``"custom_dns"``. //
+
+ This corresponds to the ``update_mask`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration, dns_settings, update_mask])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.ConfigureDnsSettingsRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.ConfigureDnsSettingsRequest):
+ request = domains.ConfigureDnsSettingsRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+ if dns_settings is not None:
+ request.dns_settings = dns_settings
+ if update_mask is not None:
+ request.update_mask = update_mask
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.configure_dns_settings]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def configure_contact_settings(
+ self,
+ request: Union[domains.ConfigureContactSettingsRequest, dict] = None,
+ *,
+ registration: str = None,
+ contact_settings: domains.ContactSettings = None,
+ update_mask: field_mask_pb2.FieldMask = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Updates a ``Registration``'s contact settings. Some changes
+ require confirmation by the domain's registrant contact .
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.ConfigureContactSettingsRequest, dict]):
+ The request object. Request for the
+ `ConfigureContactSettings` method.
+ registration (str):
+ Required. The name of the ``Registration`` whose contact
+ settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ contact_settings (google.cloud.domains_v1.types.ContactSettings):
+ Fields of the ``ContactSettings`` to update.
+ This corresponds to the ``contact_settings`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ update_mask (google.protobuf.field_mask_pb2.FieldMask):
+ Required. The field mask describing which fields to
+ update as a comma-separated list. For example, if only
+ the registrant contact is being updated, the
+ ``update_mask`` is ``"registrant_contact"``.
+
+ This corresponds to the ``update_mask`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration, contact_settings, update_mask])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.ConfigureContactSettingsRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.ConfigureContactSettingsRequest):
+ request = domains.ConfigureContactSettingsRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+ if contact_settings is not None:
+ request.contact_settings = contact_settings
+ if update_mask is not None:
+ request.update_mask = update_mask
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[
+ self._transport.configure_contact_settings
+ ]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def export_registration(
+ self,
+ request: Union[domains.ExportRegistrationRequest, dict] = None,
+ *,
+ name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Exports a ``Registration`` resource, such that it is no longer
+ managed by Cloud Domains.
+
+ When an active domain is successfully exported, you can continue
+ to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.ExportRegistrationRequest, dict]):
+ The request object. Request for the `ExportRegistration`
+ method.
+ name (str):
+ Required. The name of the ``Registration`` to export, in
+ the format ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.ExportRegistrationRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.ExportRegistrationRequest):
+ request = domains.ExportRegistrationRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if name is not None:
+ request.name = name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.export_registration]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def delete_registration(
+ self,
+ request: Union[domains.DeleteRegistrationRequest, dict] = None,
+ *,
+ name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Deletes a ``Registration`` resource.
+
+ This method works on any ``Registration`` resource using
+ `Subscription or Commitment
+ billing </domains/pricing#billing-models>`__, provided that the
+ resource was created at least 1 day in the past.
+
+ For ``Registration`` resources using `Monthly
+ billing </domains/pricing#billing-models>`__, this method works
+ if:
+
+ - ``state`` is ``EXPORTED`` with ``expire_time`` in the past
+ - ``state`` is ``REGISTRATION_FAILED``
+ - ``state`` is ``TRANSFER_FAILED``
+
+ When an active registration is successfully deleted, you can
+ continue to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.DeleteRegistrationRequest, dict]):
+ The request object. Request for the `DeleteRegistration`
+ method.
+ name (str):
+ Required. The name of the ``Registration`` to delete, in
+ the format ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.protobuf.empty_pb2.Empty` A generic empty message that you can re-use to avoid defining duplicated
+ empty messages in your APIs. A typical example is to
+ use it as the request or the response type of an API
+ method. For instance:
+
+ service Foo {
+ rpc Bar(google.protobuf.Empty) returns
+ (google.protobuf.Empty);
+
+ }
+
+ The JSON representation for Empty is empty JSON
+ object {}.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.DeleteRegistrationRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.DeleteRegistrationRequest):
+ request = domains.DeleteRegistrationRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if name is not None:
+ request.name = name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.delete_registration]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ empty_pb2.Empty,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
+ def retrieve_authorization_code(
+ self,
+ request: Union[domains.RetrieveAuthorizationCodeRequest, dict] = None,
+ *,
+ registration: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.AuthorizationCode:
+ r"""Gets the authorization code of the ``Registration`` for the
+ purpose of transferring the domain to another registrar.
+
+ You can call this method only after 60 days have elapsed since
+ the initial domain registration.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.RetrieveAuthorizationCodeRequest, dict]):
+ The request object. Request for the
+ `RetrieveAuthorizationCode` method.
+ registration (str):
+ Required. The name of the ``Registration`` whose
+ authorization code is being retrieved, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.AuthorizationCode:
+ Defines an authorization code.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.RetrieveAuthorizationCodeRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.RetrieveAuthorizationCodeRequest):
+ request = domains.RetrieveAuthorizationCodeRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[
+ self._transport.retrieve_authorization_code
+ ]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ def reset_authorization_code(
+ self,
+ request: Union[domains.ResetAuthorizationCodeRequest, dict] = None,
+ *,
+ registration: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.AuthorizationCode:
+ r"""Resets the authorization code of the ``Registration`` to a new
+ random string.
+
+ You can call this method only after 60 days have elapsed since
+ the initial domain registration.
+
+ Args:
+ request (Union[google.cloud.domains_v1.types.ResetAuthorizationCodeRequest, dict]):
+ The request object. Request for the
+ `ResetAuthorizationCode` method.
+ registration (str):
+ Required. The name of the ``Registration`` whose
+ authorization code is being reset, in the format
+ ``projects/*/locations/*/registrations/*``.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1.types.AuthorizationCode:
+ Defines an authorization code.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([registration])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.ResetAuthorizationCodeRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.ResetAuthorizationCodeRequest):
+ request = domains.ResetAuthorizationCodeRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if registration is not None:
+ request.registration = registration
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.reset_authorization_code]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata(
+ (("registration", request.registration),)
+ ),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, type, value, traceback):
+ """Releases underlying transport's resources.
+
+ .. warning::
+ ONLY use as a context manager if the transport is NOT shared
+ with other clients! Exiting the with block will CLOSE the transport
+ and may cause errors in other clients!
+ """
+ self.transport.close()
+
+
+try:
+ DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+ gapic_version=pkg_resources.get_distribution("google-cloud-domains",).version,
+ )
+except pkg_resources.DistributionNotFound:
+ DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo()
+
+
+__all__ = ("DomainsClient",)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/pagers.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/pagers.py
new file mode 100644
index 000000000000..2e777ffbe554
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/pagers.py
@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
+from typing import (
+ Any,
+ AsyncIterator,
+ Awaitable,
+ Callable,
+ Sequence,
+ Tuple,
+ Optional,
+ Iterator,
+)
+
+from google.cloud.domains_v1.types import domains
+
+
+class ListRegistrationsPager:
+ """A pager for iterating through ``list_registrations`` requests.
+
+ This class thinly wraps an initial
+ :class:`google.cloud.domains_v1.types.ListRegistrationsResponse` object, and
+ provides an ``__iter__`` method to iterate through its
+ ``registrations`` field.
+
+ If there are more pages, the ``__iter__`` method will make additional
+ ``ListRegistrations`` requests and continue to iterate
+ through the ``registrations`` field on the
+ corresponding responses.
+
+ All the usual :class:`google.cloud.domains_v1.types.ListRegistrationsResponse`
+ attributes are available on the pager. If multiple requests are made, only
+ the most recent response is retained, and thus used for attribute lookup.
+ """
+
+ def __init__(
+ self,
+ method: Callable[..., domains.ListRegistrationsResponse],
+ request: domains.ListRegistrationsRequest,
+ response: domains.ListRegistrationsResponse,
+ *,
+ metadata: Sequence[Tuple[str, str]] = ()
+ ):
+ """Instantiate the pager.
+
+ Args:
+ method (Callable): The method that was originally called, and
+ which instantiated this pager.
+ request (google.cloud.domains_v1.types.ListRegistrationsRequest):
+ The initial request object.
+ response (google.cloud.domains_v1.types.ListRegistrationsResponse):
+ The initial response object.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+ """
+ self._method = method
+ self._request = domains.ListRegistrationsRequest(request)
+ self._response = response
+ self._metadata = metadata
+
+ def __getattr__(self, name: str) -> Any:
+ return getattr(self._response, name)
+
+ @property
+ def pages(self) -> Iterator[domains.ListRegistrationsResponse]:
+ yield self._response
+ while self._response.next_page_token:
+ self._request.page_token = self._response.next_page_token
+ self._response = self._method(self._request, metadata=self._metadata)
+ yield self._response
+
+ def __iter__(self) -> Iterator[domains.Registration]:
+ for page in self.pages:
+ yield from page.registrations
+
+ def __repr__(self) -> str:
+ return "{0}<{1!r}>".format(self.__class__.__name__, self._response)
+
+
+class ListRegistrationsAsyncPager:
+ """A pager for iterating through ``list_registrations`` requests.
+
+ This class thinly wraps an initial
+ :class:`google.cloud.domains_v1.types.ListRegistrationsResponse` object, and
+ provides an ``__aiter__`` method to iterate through its
+ ``registrations`` field.
+
+ If there are more pages, the ``__aiter__`` method will make additional
+ ``ListRegistrations`` requests and continue to iterate
+ through the ``registrations`` field on the
+ corresponding responses.
+
+ All the usual :class:`google.cloud.domains_v1.types.ListRegistrationsResponse`
+ attributes are available on the pager. If multiple requests are made, only
+ the most recent response is retained, and thus used for attribute lookup.
+ """
+
+ def __init__(
+ self,
+ method: Callable[..., Awaitable[domains.ListRegistrationsResponse]],
+ request: domains.ListRegistrationsRequest,
+ response: domains.ListRegistrationsResponse,
+ *,
+ metadata: Sequence[Tuple[str, str]] = ()
+ ):
+ """Instantiates the pager.
+
+ Args:
+ method (Callable): The method that was originally called, and
+ which instantiated this pager.
+ request (google.cloud.domains_v1.types.ListRegistrationsRequest):
+ The initial request object.
+ response (google.cloud.domains_v1.types.ListRegistrationsResponse):
+ The initial response object.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+ """
+ self._method = method
+ self._request = domains.ListRegistrationsRequest(request)
+ self._response = response
+ self._metadata = metadata
+
+ def __getattr__(self, name: str) -> Any:
+ return getattr(self._response, name)
+
+ @property
+ async def pages(self) -> AsyncIterator[domains.ListRegistrationsResponse]:
+ yield self._response
+ while self._response.next_page_token:
+ self._request.page_token = self._response.next_page_token
+ self._response = await self._method(self._request, metadata=self._metadata)
+ yield self._response
+
+ def __aiter__(self) -> AsyncIterator[domains.Registration]:
+ async def async_generator():
+ async for page in self.pages:
+ for response in page.registrations:
+ yield response
+
+ return async_generator()
+
+ def __repr__(self) -> str:
+ return "{0}<{1!r}>".format(self.__class__.__name__, self._response)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/__init__.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/__init__.py
new file mode 100644
index 000000000000..d1eb105167d3
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/__init__.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
+from collections import OrderedDict
+from typing import Dict, Type
+
+from .base import DomainsTransport
+from .grpc import DomainsGrpcTransport
+from .grpc_asyncio import DomainsGrpcAsyncIOTransport
+
+
+# Compile a registry of transports.
+_transport_registry = OrderedDict() # type: Dict[str, Type[DomainsTransport]]
+_transport_registry["grpc"] = DomainsGrpcTransport
+_transport_registry["grpc_asyncio"] = DomainsGrpcAsyncIOTransport
+
+__all__ = (
+ "DomainsTransport",
+ "DomainsGrpcTransport",
+ "DomainsGrpcAsyncIOTransport",
+)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/base.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/base.py
new file mode 100644
index 000000000000..522654df8f02
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/base.py
@@ -0,0 +1,377 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import abc
+from typing import Awaitable, Callable, Dict, Optional, Sequence, Union
+import packaging.version
+import pkg_resources
+
+import google.auth # type: ignore
+import google.api_core # type: ignore
+from google.api_core import exceptions as core_exceptions # type: ignore
+from google.api_core import gapic_v1 # type: ignore
+from google.api_core import retry as retries # type: ignore
+from google.api_core import operations_v1 # type: ignore
+from google.auth import credentials as ga_credentials # type: ignore
+from google.oauth2 import service_account # type: ignore
+
+from google.cloud.domains_v1.types import domains
+from google.longrunning import operations_pb2 # type: ignore
+
+try:
+ DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+ gapic_version=pkg_resources.get_distribution("google-cloud-domains",).version,
+ )
+except pkg_resources.DistributionNotFound:
+ DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo()
+
+try:
+ # google.auth.__version__ was added in 1.26.0
+ _GOOGLE_AUTH_VERSION = google.auth.__version__
+except AttributeError:
+ try: # try pkg_resources if it is available
+ _GOOGLE_AUTH_VERSION = pkg_resources.get_distribution("google-auth").version
+ except pkg_resources.DistributionNotFound: # pragma: NO COVER
+ _GOOGLE_AUTH_VERSION = None
+
+
+class DomainsTransport(abc.ABC):
+ """Abstract transport class for Domains."""
+
+ AUTH_SCOPES = ("https://www.googleapis.com/auth/cloud-platform",)
+
+ DEFAULT_HOST: str = "domains.googleapis.com"
+
+ def __init__(
+ self,
+ *,
+ host: str = DEFAULT_HOST,
+ credentials: ga_credentials.Credentials = None,
+ credentials_file: Optional[str] = None,
+ scopes: Optional[Sequence[str]] = None,
+ quota_project_id: Optional[str] = None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ always_use_jwt_access: Optional[bool] = False,
+ **kwargs,
+ ) -> None:
+ """Instantiate the transport.
+
+ Args:
+ host (Optional[str]):
+ The hostname to connect to.
+ credentials (Optional[google.auth.credentials.Credentials]): The
+ authorization credentials to attach to requests. These
+ credentials identify the application to the service; if none
+ are specified, the client will attempt to ascertain the
+ credentials from the environment.
+ credentials_file (Optional[str]): A file with credentials that can
+ be loaded with :func:`google.auth.load_credentials_from_file`.
+ This argument is mutually exclusive with credentials.
+ scopes (Optional[Sequence[str]]): A list of scopes.
+ quota_project_id (Optional[str]): An optional project to use for billing
+ and quota.
+ client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+ The client info used to send a user-agent string along with
+ API requests. If ``None``, then default info will be used.
+ Generally, you only need to set this if you're developing
+ your own client library.
+ always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+ be used for service account credentials.
+ """
+ # Save the hostname. Default to port 443 (HTTPS) if none is specified.
+ if ":" not in host:
+ host += ":443"
+ self._host = host
+
+ scopes_kwargs = self._get_scopes_kwargs(self._host, scopes)
+
+ # Save the scopes.
+ self._scopes = scopes
+
+ # If no credentials are provided, then determine the appropriate
+ # defaults.
+ if credentials and credentials_file:
+ raise core_exceptions.DuplicateCredentialArgs(
+ "'credentials_file' and 'credentials' are mutually exclusive"
+ )
+
+ if credentials_file is not None:
+ credentials, _ = google.auth.load_credentials_from_file(
+ credentials_file, **scopes_kwargs, quota_project_id=quota_project_id
+ )
+
+ elif credentials is None:
+ credentials, _ = google.auth.default(
+ **scopes_kwargs, quota_project_id=quota_project_id
+ )
+
+ # If the credentials are service account credentials, then always try to use self signed JWT.
+ if (
+ always_use_jwt_access
+ and isinstance(credentials, service_account.Credentials)
+ and hasattr(service_account.Credentials, "with_always_use_jwt_access")
+ ):
+ credentials = credentials.with_always_use_jwt_access(True)
+
+ # Save the credentials.
+ self._credentials = credentials
+
+ # TODO(busunkim): This method is in the base transport
+ # to avoid duplicating code across the transport classes. These functions
+ # should be deleted once the minimum required versions of google-auth is increased.
+
+ # TODO: Remove this function once google-auth >= 1.25.0 is required
+ @classmethod
+ def _get_scopes_kwargs(
+ cls, host: str, scopes: Optional[Sequence[str]]
+ ) -> Dict[str, Optional[Sequence[str]]]:
+ """Returns scopes kwargs to pass to google-auth methods depending on the google-auth version"""
+
+ scopes_kwargs = {}
+
+ if _GOOGLE_AUTH_VERSION and (
+ packaging.version.parse(_GOOGLE_AUTH_VERSION)
+ >= packaging.version.parse("1.25.0")
+ ):
+ scopes_kwargs = {"scopes": scopes, "default_scopes": cls.AUTH_SCOPES}
+ else:
+ scopes_kwargs = {"scopes": scopes or cls.AUTH_SCOPES}
+
+ return scopes_kwargs
+
+ def _prep_wrapped_messages(self, client_info):
+ # Precompute the wrapped methods.
+ self._wrapped_methods = {
+ self.search_domains: gapic_v1.method.wrap_method(
+ self.search_domains, default_timeout=None, client_info=client_info,
+ ),
+ self.retrieve_register_parameters: gapic_v1.method.wrap_method(
+ self.retrieve_register_parameters,
+ default_timeout=None,
+ client_info=client_info,
+ ),
+ self.register_domain: gapic_v1.method.wrap_method(
+ self.register_domain, default_timeout=None, client_info=client_info,
+ ),
+ self.retrieve_transfer_parameters: gapic_v1.method.wrap_method(
+ self.retrieve_transfer_parameters,
+ default_timeout=None,
+ client_info=client_info,
+ ),
+ self.transfer_domain: gapic_v1.method.wrap_method(
+ self.transfer_domain, default_timeout=None, client_info=client_info,
+ ),
+ self.list_registrations: gapic_v1.method.wrap_method(
+ self.list_registrations, default_timeout=None, client_info=client_info,
+ ),
+ self.get_registration: gapic_v1.method.wrap_method(
+ self.get_registration, default_timeout=None, client_info=client_info,
+ ),
+ self.update_registration: gapic_v1.method.wrap_method(
+ self.update_registration, default_timeout=None, client_info=client_info,
+ ),
+ self.configure_management_settings: gapic_v1.method.wrap_method(
+ self.configure_management_settings,
+ default_timeout=None,
+ client_info=client_info,
+ ),
+ self.configure_dns_settings: gapic_v1.method.wrap_method(
+ self.configure_dns_settings,
+ default_timeout=None,
+ client_info=client_info,
+ ),
+ self.configure_contact_settings: gapic_v1.method.wrap_method(
+ self.configure_contact_settings,
+ default_timeout=None,
+ client_info=client_info,
+ ),
+ self.export_registration: gapic_v1.method.wrap_method(
+ self.export_registration, default_timeout=None, client_info=client_info,
+ ),
+ self.delete_registration: gapic_v1.method.wrap_method(
+ self.delete_registration, default_timeout=None, client_info=client_info,
+ ),
+ self.retrieve_authorization_code: gapic_v1.method.wrap_method(
+ self.retrieve_authorization_code,
+ default_timeout=None,
+ client_info=client_info,
+ ),
+ self.reset_authorization_code: gapic_v1.method.wrap_method(
+ self.reset_authorization_code,
+ default_timeout=None,
+ client_info=client_info,
+ ),
+ }
+
+ def close(self):
+ """Closes resources associated with the transport.
+
+ .. warning::
+ Only call this method if the transport is NOT shared
+ with other clients - this may cause errors in other clients!
+ """
+ raise NotImplementedError()
+
+ @property
+ def operations_client(self) -> operations_v1.OperationsClient:
+ """Return the client designed to process long-running operations."""
+ raise NotImplementedError()
+
+ @property
+ def search_domains(
+ self,
+ ) -> Callable[
+ [domains.SearchDomainsRequest],
+ Union[domains.SearchDomainsResponse, Awaitable[domains.SearchDomainsResponse]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def retrieve_register_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveRegisterParametersRequest],
+ Union[
+ domains.RetrieveRegisterParametersResponse,
+ Awaitable[domains.RetrieveRegisterParametersResponse],
+ ],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def register_domain(
+ self,
+ ) -> Callable[
+ [domains.RegisterDomainRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def retrieve_transfer_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveTransferParametersRequest],
+ Union[
+ domains.RetrieveTransferParametersResponse,
+ Awaitable[domains.RetrieveTransferParametersResponse],
+ ],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def transfer_domain(
+ self,
+ ) -> Callable[
+ [domains.TransferDomainRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def list_registrations(
+ self,
+ ) -> Callable[
+ [domains.ListRegistrationsRequest],
+ Union[
+ domains.ListRegistrationsResponse,
+ Awaitable[domains.ListRegistrationsResponse],
+ ],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def get_registration(
+ self,
+ ) -> Callable[
+ [domains.GetRegistrationRequest],
+ Union[domains.Registration, Awaitable[domains.Registration]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def update_registration(
+ self,
+ ) -> Callable[
+ [domains.UpdateRegistrationRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def configure_management_settings(
+ self,
+ ) -> Callable[
+ [domains.ConfigureManagementSettingsRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def configure_dns_settings(
+ self,
+ ) -> Callable[
+ [domains.ConfigureDnsSettingsRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def configure_contact_settings(
+ self,
+ ) -> Callable[
+ [domains.ConfigureContactSettingsRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def export_registration(
+ self,
+ ) -> Callable[
+ [domains.ExportRegistrationRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def delete_registration(
+ self,
+ ) -> Callable[
+ [domains.DeleteRegistrationRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def retrieve_authorization_code(
+ self,
+ ) -> Callable[
+ [domains.RetrieveAuthorizationCodeRequest],
+ Union[domains.AuthorizationCode, Awaitable[domains.AuthorizationCode]],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def reset_authorization_code(
+ self,
+ ) -> Callable[
+ [domains.ResetAuthorizationCodeRequest],
+ Union[domains.AuthorizationCode, Awaitable[domains.AuthorizationCode]],
+ ]:
+ raise NotImplementedError()
+
+
+__all__ = ("DomainsTransport",)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/grpc.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/grpc.py
new file mode 100644
index 000000000000..d4c7f2d63899
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/grpc.py
@@ -0,0 +1,748 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import warnings
+from typing import Callable, Dict, Optional, Sequence, Tuple, Union
+
+from google.api_core import grpc_helpers # type: ignore
+from google.api_core import operations_v1 # type: ignore
+from google.api_core import gapic_v1 # type: ignore
+import google.auth # type: ignore
+from google.auth import credentials as ga_credentials # type: ignore
+from google.auth.transport.grpc import SslCredentials # type: ignore
+
+import grpc # type: ignore
+
+from google.cloud.domains_v1.types import domains
+from google.longrunning import operations_pb2 # type: ignore
+from .base import DomainsTransport, DEFAULT_CLIENT_INFO
+
+
+class DomainsGrpcTransport(DomainsTransport):
+ """gRPC backend transport for Domains.
+
+ The Cloud Domains API enables management and configuration of
+ domain names.
+
+ This class defines the same methods as the primary client, so the
+ primary client can load the underlying transport implementation
+ and call it.
+
+ It sends protocol buffers over the wire using gRPC (which is built on
+ top of HTTP/2); the ``grpcio`` package must be installed.
+ """
+
+ _stubs: Dict[str, Callable]
+
+ def __init__(
+ self,
+ *,
+ host: str = "domains.googleapis.com",
+ credentials: ga_credentials.Credentials = None,
+ credentials_file: str = None,
+ scopes: Sequence[str] = None,
+ channel: grpc.Channel = None,
+ api_mtls_endpoint: str = None,
+ client_cert_source: Callable[[], Tuple[bytes, bytes]] = None,
+ ssl_channel_credentials: grpc.ChannelCredentials = None,
+ client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
+ quota_project_id: Optional[str] = None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ always_use_jwt_access: Optional[bool] = False,
+ ) -> None:
+ """Instantiate the transport.
+
+ Args:
+ host (Optional[str]):
+ The hostname to connect to.
+ credentials (Optional[google.auth.credentials.Credentials]): The
+ authorization credentials to attach to requests. These
+ credentials identify the application to the service; if none
+ are specified, the client will attempt to ascertain the
+ credentials from the environment.
+ This argument is ignored if ``channel`` is provided.
+ credentials_file (Optional[str]): A file with credentials that can
+ be loaded with :func:`google.auth.load_credentials_from_file`.
+ This argument is ignored if ``channel`` is provided.
+ scopes (Optional(Sequence[str])): A list of scopes. This argument is
+ ignored if ``channel`` is provided.
+ channel (Optional[grpc.Channel]): A ``Channel`` instance through
+ which to make calls.
+ api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
+ If provided, it overrides the ``host`` argument and tries to create
+ a mutual TLS channel with client SSL credentials from
+ ``client_cert_source`` or application default SSL credentials.
+ client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
+ Deprecated. A callback to provide client SSL certificate bytes and
+ private key bytes, both in PEM format. It is ignored if
+ ``api_mtls_endpoint`` is None.
+ ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
+ for the grpc channel. It is ignored if ``channel`` is provided.
+ client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
+ A callback to provide client certificate bytes and private key bytes,
+ both in PEM format. It is used to configure a mutual TLS channel. It is
+ ignored if ``channel`` or ``ssl_channel_credentials`` is provided.
+ quota_project_id (Optional[str]): An optional project to use for billing
+ and quota.
+ client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+ The client info used to send a user-agent string along with
+ API requests. If ``None``, then default info will be used.
+ Generally, you only need to set this if you're developing
+ your own client library.
+ always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+ be used for service account credentials.
+
+ Raises:
+ google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
+ creation failed for any reason.
+ google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+ and ``credentials_file`` are passed.
+ """
+ self._grpc_channel = None
+ self._ssl_channel_credentials = ssl_channel_credentials
+ self._stubs: Dict[str, Callable] = {}
+ self._operations_client = None
+
+ if api_mtls_endpoint:
+ warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
+ if client_cert_source:
+ warnings.warn("client_cert_source is deprecated", DeprecationWarning)
+
+ if channel:
+ # Ignore credentials if a channel was passed.
+ credentials = False
+ # If a channel was explicitly provided, set it.
+ self._grpc_channel = channel
+ self._ssl_channel_credentials = None
+
+ else:
+ if api_mtls_endpoint:
+ host = api_mtls_endpoint
+
+ # Create SSL credentials with client_cert_source or application
+ # default SSL credentials.
+ if client_cert_source:
+ cert, key = client_cert_source()
+ self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+ certificate_chain=cert, private_key=key
+ )
+ else:
+ self._ssl_channel_credentials = SslCredentials().ssl_credentials
+
+ else:
+ if client_cert_source_for_mtls and not ssl_channel_credentials:
+ cert, key = client_cert_source_for_mtls()
+ self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+ certificate_chain=cert, private_key=key
+ )
+
+ # The base transport sets the host, credentials and scopes
+ super().__init__(
+ host=host,
+ credentials=credentials,
+ credentials_file=credentials_file,
+ scopes=scopes,
+ quota_project_id=quota_project_id,
+ client_info=client_info,
+ always_use_jwt_access=always_use_jwt_access,
+ )
+
+ if not self._grpc_channel:
+ self._grpc_channel = type(self).create_channel(
+ self._host,
+ credentials=self._credentials,
+ credentials_file=credentials_file,
+ scopes=self._scopes,
+ ssl_credentials=self._ssl_channel_credentials,
+ quota_project_id=quota_project_id,
+ options=[
+ ("grpc.max_send_message_length", -1),
+ ("grpc.max_receive_message_length", -1),
+ ],
+ )
+
+ # Wrap messages. This must be done after self._grpc_channel exists
+ self._prep_wrapped_messages(client_info)
+
+ @classmethod
+ def create_channel(
+ cls,
+ host: str = "domains.googleapis.com",
+ credentials: ga_credentials.Credentials = None,
+ credentials_file: str = None,
+ scopes: Optional[Sequence[str]] = None,
+ quota_project_id: Optional[str] = None,
+ **kwargs,
+ ) -> grpc.Channel:
+ """Create and return a gRPC channel object.
+ Args:
+ host (Optional[str]): The host for the channel to use.
+ credentials (Optional[~.Credentials]): The
+ authorization credentials to attach to requests. These
+ credentials identify this application to the service. If
+ none are specified, the client will attempt to ascertain
+ the credentials from the environment.
+ credentials_file (Optional[str]): A file with credentials that can
+ be loaded with :func:`google.auth.load_credentials_from_file`.
+ This argument is mutually exclusive with credentials.
+ scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+ service. These are only used when credentials are not specified and
+ are passed to :func:`google.auth.default`.
+ quota_project_id (Optional[str]): An optional project to use for billing
+ and quota.
+ kwargs (Optional[dict]): Keyword arguments, which are passed to the
+ channel creation.
+ Returns:
+ grpc.Channel: A gRPC channel object.
+
+ Raises:
+ google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+ and ``credentials_file`` are passed.
+ """
+
+ return grpc_helpers.create_channel(
+ host,
+ credentials=credentials,
+ credentials_file=credentials_file,
+ quota_project_id=quota_project_id,
+ default_scopes=cls.AUTH_SCOPES,
+ scopes=scopes,
+ default_host=cls.DEFAULT_HOST,
+ **kwargs,
+ )
+
+ @property
+ def grpc_channel(self) -> grpc.Channel:
+ """Return the channel designed to connect to this service.
+ """
+ return self._grpc_channel
+
+ @property
+ def operations_client(self) -> operations_v1.OperationsClient:
+ """Create the client designed to process long-running operations.
+
+ This property caches on the instance; repeated calls return the same
+ client.
+ """
+ # Sanity check: Only create a new client if we do not already have one.
+ if self._operations_client is None:
+ self._operations_client = operations_v1.OperationsClient(self.grpc_channel)
+
+ # Return the client from cache.
+ return self._operations_client
+
+ @property
+ def search_domains(
+ self,
+ ) -> Callable[[domains.SearchDomainsRequest], domains.SearchDomainsResponse]:
+ r"""Return a callable for the search domains method over gRPC.
+
+ Searches for available domain names similar to the provided
+ query.
+
+ Availability results from this method are approximate; call
+ ``RetrieveRegisterParameters`` on a domain before registering to
+ confirm availability.
+
+ Returns:
+ Callable[[~.SearchDomainsRequest],
+ ~.SearchDomainsResponse]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "search_domains" not in self._stubs:
+ self._stubs["search_domains"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/SearchDomains",
+ request_serializer=domains.SearchDomainsRequest.serialize,
+ response_deserializer=domains.SearchDomainsResponse.deserialize,
+ )
+ return self._stubs["search_domains"]
+
+ @property
+ def retrieve_register_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveRegisterParametersRequest],
+ domains.RetrieveRegisterParametersResponse,
+ ]:
+ r"""Return a callable for the retrieve register parameters method over gRPC.
+
+ Gets parameters needed to register a new domain name, including
+ price and up-to-date availability. Use the returned values to
+ call ``RegisterDomain``.
+
+ Returns:
+ Callable[[~.RetrieveRegisterParametersRequest],
+ ~.RetrieveRegisterParametersResponse]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "retrieve_register_parameters" not in self._stubs:
+ self._stubs["retrieve_register_parameters"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/RetrieveRegisterParameters",
+ request_serializer=domains.RetrieveRegisterParametersRequest.serialize,
+ response_deserializer=domains.RetrieveRegisterParametersResponse.deserialize,
+ )
+ return self._stubs["retrieve_register_parameters"]
+
+ @property
+ def register_domain(
+ self,
+ ) -> Callable[[domains.RegisterDomainRequest], operations_pb2.Operation]:
+ r"""Return a callable for the register domain method over gRPC.
+
+ Registers a new domain name and creates a corresponding
+ ``Registration`` resource.
+
+ Call ``RetrieveRegisterParameters`` first to check availability
+ of the domain name and determine parameters like price that are
+ needed to build a call to this method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``REGISTRATION_PENDING``, which resolves to ``ACTIVE`` within
+ 1-2 minutes, indicating that the domain was successfully
+ registered. If the resource ends up in state
+ ``REGISTRATION_FAILED``, it indicates that the domain was not
+ registered successfully, and you can safely delete the resource
+ and retry registration.
+
+ Returns:
+ Callable[[~.RegisterDomainRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "register_domain" not in self._stubs:
+ self._stubs["register_domain"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/RegisterDomain",
+ request_serializer=domains.RegisterDomainRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["register_domain"]
+
+ @property
+ def retrieve_transfer_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveTransferParametersRequest],
+ domains.RetrieveTransferParametersResponse,
+ ]:
+ r"""Return a callable for the retrieve transfer parameters method over gRPC.
+
+ Gets parameters needed to transfer a domain name from another
+ registrar to Cloud Domains. For domains managed by Google
+ Domains, transferring to Cloud Domains is not supported.
+
+ Use the returned values to call ``TransferDomain``.
+
+ Returns:
+ Callable[[~.RetrieveTransferParametersRequest],
+ ~.RetrieveTransferParametersResponse]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "retrieve_transfer_parameters" not in self._stubs:
+ self._stubs["retrieve_transfer_parameters"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/RetrieveTransferParameters",
+ request_serializer=domains.RetrieveTransferParametersRequest.serialize,
+ response_deserializer=domains.RetrieveTransferParametersResponse.deserialize,
+ )
+ return self._stubs["retrieve_transfer_parameters"]
+
+ @property
+ def transfer_domain(
+ self,
+ ) -> Callable[[domains.TransferDomainRequest], operations_pb2.Operation]:
+ r"""Return a callable for the transfer domain method over gRPC.
+
+ Transfers a domain name from another registrar to Cloud Domains.
+ For domains managed by Google Domains, transferring to Cloud
+ Domains is not supported.
+
+ Before calling this method, go to the domain's current registrar
+ to unlock the domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to this
+ method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``TRANSFER_PENDING``. It can take several days to complete the
+ transfer process. The registrant can often speed up this process
+ by approving the transfer through the current registrar, either
+ by clicking a link in an email from the registrar or by visiting
+ the registrar's website.
+
+ A few minutes after transfer approval, the resource transitions
+ to state ``ACTIVE``, indicating that the transfer was
+ successful. If the transfer is rejected or the request expires
+ without being approved, the resource can end up in state
+ ``TRANSFER_FAILED``. If transfer fails, you can safely delete
+ the resource and retry the transfer.
+
+ Returns:
+ Callable[[~.TransferDomainRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "transfer_domain" not in self._stubs:
+ self._stubs["transfer_domain"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/TransferDomain",
+ request_serializer=domains.TransferDomainRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["transfer_domain"]
+
+ @property
+ def list_registrations(
+ self,
+ ) -> Callable[
+ [domains.ListRegistrationsRequest], domains.ListRegistrationsResponse
+ ]:
+ r"""Return a callable for the list registrations method over gRPC.
+
+ Lists the ``Registration`` resources in a project.
+
+ Returns:
+ Callable[[~.ListRegistrationsRequest],
+ ~.ListRegistrationsResponse]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "list_registrations" not in self._stubs:
+ self._stubs["list_registrations"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ListRegistrations",
+ request_serializer=domains.ListRegistrationsRequest.serialize,
+ response_deserializer=domains.ListRegistrationsResponse.deserialize,
+ )
+ return self._stubs["list_registrations"]
+
+ @property
+ def get_registration(
+ self,
+ ) -> Callable[[domains.GetRegistrationRequest], domains.Registration]:
+ r"""Return a callable for the get registration method over gRPC.
+
+ Gets the details of a ``Registration`` resource.
+
+ Returns:
+ Callable[[~.GetRegistrationRequest],
+ ~.Registration]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "get_registration" not in self._stubs:
+ self._stubs["get_registration"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/GetRegistration",
+ request_serializer=domains.GetRegistrationRequest.serialize,
+ response_deserializer=domains.Registration.deserialize,
+ )
+ return self._stubs["get_registration"]
+
+ @property
+ def update_registration(
+ self,
+ ) -> Callable[[domains.UpdateRegistrationRequest], operations_pb2.Operation]:
+ r"""Return a callable for the update registration method over gRPC.
+
+ Updates select fields of a ``Registration`` resource, notably
+ ``labels``. To update other fields, use the appropriate custom
+ update method:
+
+ - To update management settings, see
+ ``ConfigureManagementSettings``
+ - To update DNS configuration, see ``ConfigureDnsSettings``
+ - To update contact information, see
+ ``ConfigureContactSettings``
+
+ Returns:
+ Callable[[~.UpdateRegistrationRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "update_registration" not in self._stubs:
+ self._stubs["update_registration"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/UpdateRegistration",
+ request_serializer=domains.UpdateRegistrationRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["update_registration"]
+
+ @property
+ def configure_management_settings(
+ self,
+ ) -> Callable[
+ [domains.ConfigureManagementSettingsRequest], operations_pb2.Operation
+ ]:
+ r"""Return a callable for the configure management settings method over gRPC.
+
+ Updates a ``Registration``'s management settings.
+
+ Returns:
+ Callable[[~.ConfigureManagementSettingsRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "configure_management_settings" not in self._stubs:
+ self._stubs[
+ "configure_management_settings"
+ ] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ConfigureManagementSettings",
+ request_serializer=domains.ConfigureManagementSettingsRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["configure_management_settings"]
+
+ @property
+ def configure_dns_settings(
+ self,
+ ) -> Callable[[domains.ConfigureDnsSettingsRequest], operations_pb2.Operation]:
+ r"""Return a callable for the configure dns settings method over gRPC.
+
+ Updates a ``Registration``'s DNS settings.
+
+ Returns:
+ Callable[[~.ConfigureDnsSettingsRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "configure_dns_settings" not in self._stubs:
+ self._stubs["configure_dns_settings"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ConfigureDnsSettings",
+ request_serializer=domains.ConfigureDnsSettingsRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["configure_dns_settings"]
+
+ @property
+ def configure_contact_settings(
+ self,
+ ) -> Callable[[domains.ConfigureContactSettingsRequest], operations_pb2.Operation]:
+ r"""Return a callable for the configure contact settings method over gRPC.
+
+ Updates a ``Registration``'s contact settings. Some changes
+ require confirmation by the domain's registrant contact .
+
+ Returns:
+ Callable[[~.ConfigureContactSettingsRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "configure_contact_settings" not in self._stubs:
+ self._stubs["configure_contact_settings"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ConfigureContactSettings",
+ request_serializer=domains.ConfigureContactSettingsRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["configure_contact_settings"]
+
+ @property
+ def export_registration(
+ self,
+ ) -> Callable[[domains.ExportRegistrationRequest], operations_pb2.Operation]:
+ r"""Return a callable for the export registration method over gRPC.
+
+ Exports a ``Registration`` resource, such that it is no longer
+ managed by Cloud Domains.
+
+ When an active domain is successfully exported, you can continue
+ to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
+
+ Returns:
+ Callable[[~.ExportRegistrationRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "export_registration" not in self._stubs:
+ self._stubs["export_registration"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ExportRegistration",
+ request_serializer=domains.ExportRegistrationRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["export_registration"]
+
+ @property
+ def delete_registration(
+ self,
+ ) -> Callable[[domains.DeleteRegistrationRequest], operations_pb2.Operation]:
+ r"""Return a callable for the delete registration method over gRPC.
+
+ Deletes a ``Registration`` resource.
+
+ This method works on any ``Registration`` resource using
+ `Subscription or Commitment
+ billing </domains/pricing#billing-models>`__, provided that the
+ resource was created at least 1 day in the past.
+
+ For ``Registration`` resources using `Monthly
+ billing </domains/pricing#billing-models>`__, this method works
+ if:
+
+ - ``state`` is ``EXPORTED`` with ``expire_time`` in the past
+ - ``state`` is ``REGISTRATION_FAILED``
+ - ``state`` is ``TRANSFER_FAILED``
+
+ When an active registration is successfully deleted, you can
+ continue to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
+
+ Returns:
+ Callable[[~.DeleteRegistrationRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "delete_registration" not in self._stubs:
+ self._stubs["delete_registration"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/DeleteRegistration",
+ request_serializer=domains.DeleteRegistrationRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["delete_registration"]
+
+ @property
+ def retrieve_authorization_code(
+ self,
+ ) -> Callable[
+ [domains.RetrieveAuthorizationCodeRequest], domains.AuthorizationCode
+ ]:
+ r"""Return a callable for the retrieve authorization code method over gRPC.
+
+ Gets the authorization code of the ``Registration`` for the
+ purpose of transferring the domain to another registrar.
+
+ You can call this method only after 60 days have elapsed since
+ the initial domain registration.
+
+ Returns:
+ Callable[[~.RetrieveAuthorizationCodeRequest],
+ ~.AuthorizationCode]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "retrieve_authorization_code" not in self._stubs:
+ self._stubs["retrieve_authorization_code"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/RetrieveAuthorizationCode",
+ request_serializer=domains.RetrieveAuthorizationCodeRequest.serialize,
+ response_deserializer=domains.AuthorizationCode.deserialize,
+ )
+ return self._stubs["retrieve_authorization_code"]
+
+ @property
+ def reset_authorization_code(
+ self,
+ ) -> Callable[[domains.ResetAuthorizationCodeRequest], domains.AuthorizationCode]:
+ r"""Return a callable for the reset authorization code method over gRPC.
+
+ Resets the authorization code of the ``Registration`` to a new
+ random string.
+
+ You can call this method only after 60 days have elapsed since
+ the initial domain registration.
+
+ Returns:
+ Callable[[~.ResetAuthorizationCodeRequest],
+ ~.AuthorizationCode]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "reset_authorization_code" not in self._stubs:
+ self._stubs["reset_authorization_code"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ResetAuthorizationCode",
+ request_serializer=domains.ResetAuthorizationCodeRequest.serialize,
+ response_deserializer=domains.AuthorizationCode.deserialize,
+ )
+ return self._stubs["reset_authorization_code"]
+
+ def close(self):
+ self.grpc_channel.close()
+
+
+__all__ = ("DomainsGrpcTransport",)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/grpc_asyncio.py b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/grpc_asyncio.py
new file mode 100644
index 000000000000..50c25214658c
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/services/domains/transports/grpc_asyncio.py
@@ -0,0 +1,768 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import warnings
+from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
+
+from google.api_core import gapic_v1 # type: ignore
+from google.api_core import grpc_helpers_async # type: ignore
+from google.api_core import operations_v1 # type: ignore
+from google.auth import credentials as ga_credentials # type: ignore
+from google.auth.transport.grpc import SslCredentials # type: ignore
+import packaging.version
+
+import grpc # type: ignore
+from grpc.experimental import aio # type: ignore
+
+from google.cloud.domains_v1.types import domains
+from google.longrunning import operations_pb2 # type: ignore
+from .base import DomainsTransport, DEFAULT_CLIENT_INFO
+from .grpc import DomainsGrpcTransport
+
+
+class DomainsGrpcAsyncIOTransport(DomainsTransport):
+ """gRPC AsyncIO backend transport for Domains.
+
+ The Cloud Domains API enables management and configuration of
+ domain names.
+
+ This class defines the same methods as the primary client, so the
+ primary client can load the underlying transport implementation
+ and call it.
+
+ It sends protocol buffers over the wire using gRPC (which is built on
+ top of HTTP/2); the ``grpcio`` package must be installed.
+ """
+
+ _grpc_channel: aio.Channel
+ _stubs: Dict[str, Callable] = {}
+
+ @classmethod
+ def create_channel(
+ cls,
+ host: str = "domains.googleapis.com",
+ credentials: ga_credentials.Credentials = None,
+ credentials_file: Optional[str] = None,
+ scopes: Optional[Sequence[str]] = None,
+ quota_project_id: Optional[str] = None,
+ **kwargs,
+ ) -> aio.Channel:
+ """Create and return a gRPC AsyncIO channel object.
+ Args:
+ host (Optional[str]): The host for the channel to use.
+ credentials (Optional[~.Credentials]): The
+ authorization credentials to attach to requests. These
+ credentials identify this application to the service. If
+ none are specified, the client will attempt to ascertain
+ the credentials from the environment.
+ credentials_file (Optional[str]): A file with credentials that can
+ be loaded with :func:`google.auth.load_credentials_from_file`.
+ This argument is ignored if ``channel`` is provided.
+ scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+ service. These are only used when credentials are not specified and
+ are passed to :func:`google.auth.default`.
+ quota_project_id (Optional[str]): An optional project to use for billing
+ and quota.
+ kwargs (Optional[dict]): Keyword arguments, which are passed to the
+ channel creation.
+ Returns:
+ aio.Channel: A gRPC AsyncIO channel object.
+ """
+
+ return grpc_helpers_async.create_channel(
+ host,
+ credentials=credentials,
+ credentials_file=credentials_file,
+ quota_project_id=quota_project_id,
+ default_scopes=cls.AUTH_SCOPES,
+ scopes=scopes,
+ default_host=cls.DEFAULT_HOST,
+ **kwargs,
+ )
+
+ def __init__(
+ self,
+ *,
+ host: str = "domains.googleapis.com",
+ credentials: ga_credentials.Credentials = None,
+ credentials_file: Optional[str] = None,
+ scopes: Optional[Sequence[str]] = None,
+ channel: aio.Channel = None,
+ api_mtls_endpoint: str = None,
+ client_cert_source: Callable[[], Tuple[bytes, bytes]] = None,
+ ssl_channel_credentials: grpc.ChannelCredentials = None,
+ client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
+ quota_project_id=None,
+ client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+ always_use_jwt_access: Optional[bool] = False,
+ ) -> None:
+ """Instantiate the transport.
+
+ Args:
+ host (Optional[str]):
+ The hostname to connect to.
+ credentials (Optional[google.auth.credentials.Credentials]): The
+ authorization credentials to attach to requests. These
+ credentials identify the application to the service; if none
+ are specified, the client will attempt to ascertain the
+ credentials from the environment.
+ This argument is ignored if ``channel`` is provided.
+ credentials_file (Optional[str]): A file with credentials that can
+ be loaded with :func:`google.auth.load_credentials_from_file`.
+ This argument is ignored if ``channel`` is provided.
+ scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+ service. These are only used when credentials are not specified and
+ are passed to :func:`google.auth.default`.
+ channel (Optional[aio.Channel]): A ``Channel`` instance through
+ which to make calls.
+ api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
+ If provided, it overrides the ``host`` argument and tries to create
+ a mutual TLS channel with client SSL credentials from
+ ``client_cert_source`` or application default SSL credentials.
+ client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
+ Deprecated. A callback to provide client SSL certificate bytes and
+ private key bytes, both in PEM format. It is ignored if
+ ``api_mtls_endpoint`` is None.
+ ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
+ for the grpc channel. It is ignored if ``channel`` is provided.
+ client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
+ A callback to provide client certificate bytes and private key bytes,
+ both in PEM format. It is used to configure a mutual TLS channel. It is
+ ignored if ``channel`` or ``ssl_channel_credentials`` is provided.
+ quota_project_id (Optional[str]): An optional project to use for billing
+ and quota.
+ client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+ The client info used to send a user-agent string along with
+ API requests. If ``None``, then default info will be used.
+ Generally, you only need to set this if you're developing
+ your own client library.
+ always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+ be used for service account credentials.
+
+ Raises:
+ google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
+ creation failed for any reason.
+ google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+ and ``credentials_file`` are passed.
+ """
+ self._grpc_channel = None
+ self._ssl_channel_credentials = ssl_channel_credentials
+ self._stubs: Dict[str, Callable] = {}
+ self._operations_client = None
+
+ if api_mtls_endpoint:
+ warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
+ if client_cert_source:
+ warnings.warn("client_cert_source is deprecated", DeprecationWarning)
+
+ if channel:
+ # Ignore credentials if a channel was passed.
+ credentials = False
+ # If a channel was explicitly provided, set it.
+ self._grpc_channel = channel
+ self._ssl_channel_credentials = None
+ else:
+ if api_mtls_endpoint:
+ host = api_mtls_endpoint
+
+ # Create SSL credentials with client_cert_source or application
+ # default SSL credentials.
+ if client_cert_source:
+ cert, key = client_cert_source()
+ self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+ certificate_chain=cert, private_key=key
+ )
+ else:
+ self._ssl_channel_credentials = SslCredentials().ssl_credentials
+
+ else:
+ if client_cert_source_for_mtls and not ssl_channel_credentials:
+ cert, key = client_cert_source_for_mtls()
+ self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+ certificate_chain=cert, private_key=key
+ )
+
+ # The base transport sets the host, credentials and scopes
+ super().__init__(
+ host=host,
+ credentials=credentials,
+ credentials_file=credentials_file,
+ scopes=scopes,
+ quota_project_id=quota_project_id,
+ client_info=client_info,
+ always_use_jwt_access=always_use_jwt_access,
+ )
+
+ if not self._grpc_channel:
+ self._grpc_channel = type(self).create_channel(
+ self._host,
+ credentials=self._credentials,
+ credentials_file=credentials_file,
+ scopes=self._scopes,
+ ssl_credentials=self._ssl_channel_credentials,
+ quota_project_id=quota_project_id,
+ options=[
+ ("grpc.max_send_message_length", -1),
+ ("grpc.max_receive_message_length", -1),
+ ],
+ )
+
+ # Wrap messages. This must be done after self._grpc_channel exists
+ self._prep_wrapped_messages(client_info)
+
+ @property
+ def grpc_channel(self) -> aio.Channel:
+ """Create the channel designed to connect to this service.
+
+ This property caches on the instance; repeated calls return
+ the same channel.
+ """
+ # Return the channel from cache.
+ return self._grpc_channel
+
+ @property
+ def operations_client(self) -> operations_v1.OperationsAsyncClient:
+ """Create the client designed to process long-running operations.
+
+ This property caches on the instance; repeated calls return the same
+ client.
+ """
+ # Sanity check: Only create a new client if we do not already have one.
+ if self._operations_client is None:
+ self._operations_client = operations_v1.OperationsAsyncClient(
+ self.grpc_channel
+ )
+
+ # Return the client from cache.
+ return self._operations_client
+
+ @property
+ def search_domains(
+ self,
+ ) -> Callable[
+ [domains.SearchDomainsRequest], Awaitable[domains.SearchDomainsResponse]
+ ]:
+ r"""Return a callable for the search domains method over gRPC.
+
+ Searches for available domain names similar to the provided
+ query.
+
+ Availability results from this method are approximate; call
+ ``RetrieveRegisterParameters`` on a domain before registering to
+ confirm availability.
+
+ Returns:
+ Callable[[~.SearchDomainsRequest],
+ Awaitable[~.SearchDomainsResponse]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "search_domains" not in self._stubs:
+ self._stubs["search_domains"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/SearchDomains",
+ request_serializer=domains.SearchDomainsRequest.serialize,
+ response_deserializer=domains.SearchDomainsResponse.deserialize,
+ )
+ return self._stubs["search_domains"]
+
+ @property
+ def retrieve_register_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveRegisterParametersRequest],
+ Awaitable[domains.RetrieveRegisterParametersResponse],
+ ]:
+ r"""Return a callable for the retrieve register parameters method over gRPC.
+
+ Gets parameters needed to register a new domain name, including
+ price and up-to-date availability. Use the returned values to
+ call ``RegisterDomain``.
+
+ Returns:
+ Callable[[~.RetrieveRegisterParametersRequest],
+ Awaitable[~.RetrieveRegisterParametersResponse]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "retrieve_register_parameters" not in self._stubs:
+ self._stubs["retrieve_register_parameters"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/RetrieveRegisterParameters",
+ request_serializer=domains.RetrieveRegisterParametersRequest.serialize,
+ response_deserializer=domains.RetrieveRegisterParametersResponse.deserialize,
+ )
+ return self._stubs["retrieve_register_parameters"]
+
+ @property
+ def register_domain(
+ self,
+ ) -> Callable[[domains.RegisterDomainRequest], Awaitable[operations_pb2.Operation]]:
+ r"""Return a callable for the register domain method over gRPC.
+
+ Registers a new domain name and creates a corresponding
+ ``Registration`` resource.
+
+ Call ``RetrieveRegisterParameters`` first to check availability
+ of the domain name and determine parameters like price that are
+ needed to build a call to this method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``REGISTRATION_PENDING``, which resolves to ``ACTIVE`` within
+ 1-2 minutes, indicating that the domain was successfully
+ registered. If the resource ends up in state
+ ``REGISTRATION_FAILED``, it indicates that the domain was not
+ registered successfully, and you can safely delete the resource
+ and retry registration.
+
+ Returns:
+ Callable[[~.RegisterDomainRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "register_domain" not in self._stubs:
+ self._stubs["register_domain"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/RegisterDomain",
+ request_serializer=domains.RegisterDomainRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["register_domain"]
+
+ @property
+ def retrieve_transfer_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveTransferParametersRequest],
+ Awaitable[domains.RetrieveTransferParametersResponse],
+ ]:
+ r"""Return a callable for the retrieve transfer parameters method over gRPC.
+
+ Gets parameters needed to transfer a domain name from another
+ registrar to Cloud Domains. For domains managed by Google
+ Domains, transferring to Cloud Domains is not supported.
+
+ Use the returned values to call ``TransferDomain``.
+
+ Returns:
+ Callable[[~.RetrieveTransferParametersRequest],
+ Awaitable[~.RetrieveTransferParametersResponse]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "retrieve_transfer_parameters" not in self._stubs:
+ self._stubs["retrieve_transfer_parameters"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/RetrieveTransferParameters",
+ request_serializer=domains.RetrieveTransferParametersRequest.serialize,
+ response_deserializer=domains.RetrieveTransferParametersResponse.deserialize,
+ )
+ return self._stubs["retrieve_transfer_parameters"]
+
+ @property
+ def transfer_domain(
+ self,
+ ) -> Callable[[domains.TransferDomainRequest], Awaitable[operations_pb2.Operation]]:
+ r"""Return a callable for the transfer domain method over gRPC.
+
+ Transfers a domain name from another registrar to Cloud Domains.
+ For domains managed by Google Domains, transferring to Cloud
+ Domains is not supported.
+
+ Before calling this method, go to the domain's current registrar
+ to unlock the domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to this
+ method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``TRANSFER_PENDING``. It can take several days to complete the
+ transfer process. The registrant can often speed up this process
+ by approving the transfer through the current registrar, either
+ by clicking a link in an email from the registrar or by visiting
+ the registrar's website.
+
+ A few minutes after transfer approval, the resource transitions
+ to state ``ACTIVE``, indicating that the transfer was
+ successful. If the transfer is rejected or the request expires
+ without being approved, the resource can end up in state
+ ``TRANSFER_FAILED``. If transfer fails, you can safely delete
+ the resource and retry the transfer.
+
+ Returns:
+ Callable[[~.TransferDomainRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "transfer_domain" not in self._stubs:
+ self._stubs["transfer_domain"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/TransferDomain",
+ request_serializer=domains.TransferDomainRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["transfer_domain"]
+
+ @property
+ def list_registrations(
+ self,
+ ) -> Callable[
+ [domains.ListRegistrationsRequest], Awaitable[domains.ListRegistrationsResponse]
+ ]:
+ r"""Return a callable for the list registrations method over gRPC.
+
+ Lists the ``Registration`` resources in a project.
+
+ Returns:
+ Callable[[~.ListRegistrationsRequest],
+ Awaitable[~.ListRegistrationsResponse]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "list_registrations" not in self._stubs:
+ self._stubs["list_registrations"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ListRegistrations",
+ request_serializer=domains.ListRegistrationsRequest.serialize,
+ response_deserializer=domains.ListRegistrationsResponse.deserialize,
+ )
+ return self._stubs["list_registrations"]
+
+ @property
+ def get_registration(
+ self,
+ ) -> Callable[[domains.GetRegistrationRequest], Awaitable[domains.Registration]]:
+ r"""Return a callable for the get registration method over gRPC.
+
+ Gets the details of a ``Registration`` resource.
+
+ Returns:
+ Callable[[~.GetRegistrationRequest],
+ Awaitable[~.Registration]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "get_registration" not in self._stubs:
+ self._stubs["get_registration"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/GetRegistration",
+ request_serializer=domains.GetRegistrationRequest.serialize,
+ response_deserializer=domains.Registration.deserialize,
+ )
+ return self._stubs["get_registration"]
+
+ @property
+ def update_registration(
+ self,
+ ) -> Callable[
+ [domains.UpdateRegistrationRequest], Awaitable[operations_pb2.Operation]
+ ]:
+ r"""Return a callable for the update registration method over gRPC.
+
+ Updates select fields of a ``Registration`` resource, notably
+ ``labels``. To update other fields, use the appropriate custom
+ update method:
+
+ - To update management settings, see
+ ``ConfigureManagementSettings``
+ - To update DNS configuration, see ``ConfigureDnsSettings``
+ - To update contact information, see
+ ``ConfigureContactSettings``
+
+ Returns:
+ Callable[[~.UpdateRegistrationRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "update_registration" not in self._stubs:
+ self._stubs["update_registration"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/UpdateRegistration",
+ request_serializer=domains.UpdateRegistrationRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["update_registration"]
+
+ @property
+ def configure_management_settings(
+ self,
+ ) -> Callable[
+ [domains.ConfigureManagementSettingsRequest],
+ Awaitable[operations_pb2.Operation],
+ ]:
+ r"""Return a callable for the configure management settings method over gRPC.
+
+ Updates a ``Registration``'s management settings.
+
+ Returns:
+ Callable[[~.ConfigureManagementSettingsRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "configure_management_settings" not in self._stubs:
+ self._stubs[
+ "configure_management_settings"
+ ] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ConfigureManagementSettings",
+ request_serializer=domains.ConfigureManagementSettingsRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["configure_management_settings"]
+
+ @property
+ def configure_dns_settings(
+ self,
+ ) -> Callable[
+ [domains.ConfigureDnsSettingsRequest], Awaitable[operations_pb2.Operation]
+ ]:
+ r"""Return a callable for the configure dns settings method over gRPC.
+
+ Updates a ``Registration``'s DNS settings.
+
+ Returns:
+ Callable[[~.ConfigureDnsSettingsRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "configure_dns_settings" not in self._stubs:
+ self._stubs["configure_dns_settings"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ConfigureDnsSettings",
+ request_serializer=domains.ConfigureDnsSettingsRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["configure_dns_settings"]
+
+ @property
+ def configure_contact_settings(
+ self,
+ ) -> Callable[
+ [domains.ConfigureContactSettingsRequest], Awaitable[operations_pb2.Operation]
+ ]:
+ r"""Return a callable for the configure contact settings method over gRPC.
+
+ Updates a ``Registration``'s contact settings. Some changes
+ require confirmation by the domain's registrant contact .
+
+ Returns:
+ Callable[[~.ConfigureContactSettingsRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "configure_contact_settings" not in self._stubs:
+ self._stubs["configure_contact_settings"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ConfigureContactSettings",
+ request_serializer=domains.ConfigureContactSettingsRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["configure_contact_settings"]
+
+ @property
+ def export_registration(
+ self,
+ ) -> Callable[
+ [domains.ExportRegistrationRequest], Awaitable[operations_pb2.Operation]
+ ]:
+ r"""Return a callable for the export registration method over gRPC.
+
+ Exports a ``Registration`` resource, such that it is no longer
+ managed by Cloud Domains.
+
+ When an active domain is successfully exported, you can continue
+ to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
+
+ Returns:
+ Callable[[~.ExportRegistrationRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "export_registration" not in self._stubs:
+ self._stubs["export_registration"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ExportRegistration",
+ request_serializer=domains.ExportRegistrationRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["export_registration"]
+
+ @property
+ def delete_registration(
+ self,
+ ) -> Callable[
+ [domains.DeleteRegistrationRequest], Awaitable[operations_pb2.Operation]
+ ]:
+ r"""Return a callable for the delete registration method over gRPC.
+
+ Deletes a ``Registration`` resource.
+
+ This method works on any ``Registration`` resource using
+ `Subscription or Commitment
+ billing </domains/pricing#billing-models>`__, provided that the
+ resource was created at least 1 day in the past.
+
+ For ``Registration`` resources using `Monthly
+ billing </domains/pricing#billing-models>`__, this method works
+ if:
+
+ - ``state`` is ``EXPORTED`` with ``expire_time`` in the past
+ - ``state`` is ``REGISTRATION_FAILED``
+ - ``state`` is ``TRANSFER_FAILED``
+
+ When an active registration is successfully deleted, you can
+ continue to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
+
+ Returns:
+ Callable[[~.DeleteRegistrationRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "delete_registration" not in self._stubs:
+ self._stubs["delete_registration"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/DeleteRegistration",
+ request_serializer=domains.DeleteRegistrationRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["delete_registration"]
+
+ @property
+ def retrieve_authorization_code(
+ self,
+ ) -> Callable[
+ [domains.RetrieveAuthorizationCodeRequest], Awaitable[domains.AuthorizationCode]
+ ]:
+ r"""Return a callable for the retrieve authorization code method over gRPC.
+
+ Gets the authorization code of the ``Registration`` for the
+ purpose of transferring the domain to another registrar.
+
+ You can call this method only after 60 days have elapsed since
+ the initial domain registration.
+
+ Returns:
+ Callable[[~.RetrieveAuthorizationCodeRequest],
+ Awaitable[~.AuthorizationCode]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "retrieve_authorization_code" not in self._stubs:
+ self._stubs["retrieve_authorization_code"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/RetrieveAuthorizationCode",
+ request_serializer=domains.RetrieveAuthorizationCodeRequest.serialize,
+ response_deserializer=domains.AuthorizationCode.deserialize,
+ )
+ return self._stubs["retrieve_authorization_code"]
+
+ @property
+ def reset_authorization_code(
+ self,
+ ) -> Callable[
+ [domains.ResetAuthorizationCodeRequest], Awaitable[domains.AuthorizationCode]
+ ]:
+ r"""Return a callable for the reset authorization code method over gRPC.
+
+ Resets the authorization code of the ``Registration`` to a new
+ random string.
+
+ You can call this method only after 60 days have elapsed since
+ the initial domain registration.
+
+ Returns:
+ Callable[[~.ResetAuthorizationCodeRequest],
+ Awaitable[~.AuthorizationCode]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "reset_authorization_code" not in self._stubs:
+ self._stubs["reset_authorization_code"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1.Domains/ResetAuthorizationCode",
+ request_serializer=domains.ResetAuthorizationCodeRequest.serialize,
+ response_deserializer=domains.AuthorizationCode.deserialize,
+ )
+ return self._stubs["reset_authorization_code"]
+
+ def close(self):
+ return self.grpc_channel.close()
+
+
+__all__ = ("DomainsGrpcAsyncIOTransport",)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/types/__init__.py b/packages/google-cloud-domains/google/cloud/domains_v1/types/__init__.py
new file mode 100644
index 000000000000..2ccb2c4772d2
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/types/__init__.py
@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
+from .domains import (
+ AuthorizationCode,
+ ConfigureContactSettingsRequest,
+ ConfigureDnsSettingsRequest,
+ ConfigureManagementSettingsRequest,
+ ContactSettings,
+ DeleteRegistrationRequest,
+ DnsSettings,
+ ExportRegistrationRequest,
+ GetRegistrationRequest,
+ ListRegistrationsRequest,
+ ListRegistrationsResponse,
+ ManagementSettings,
+ OperationMetadata,
+ RegisterDomainRequest,
+ RegisterParameters,
+ Registration,
+ ResetAuthorizationCodeRequest,
+ RetrieveAuthorizationCodeRequest,
+ RetrieveRegisterParametersRequest,
+ RetrieveRegisterParametersResponse,
+ RetrieveTransferParametersRequest,
+ RetrieveTransferParametersResponse,
+ SearchDomainsRequest,
+ SearchDomainsResponse,
+ TransferDomainRequest,
+ TransferParameters,
+ UpdateRegistrationRequest,
+ ContactNotice,
+ ContactPrivacy,
+ DomainNotice,
+ TransferLockState,
+)
+
+__all__ = (
+ "AuthorizationCode",
+ "ConfigureContactSettingsRequest",
+ "ConfigureDnsSettingsRequest",
+ "ConfigureManagementSettingsRequest",
+ "ContactSettings",
+ "DeleteRegistrationRequest",
+ "DnsSettings",
+ "ExportRegistrationRequest",
+ "GetRegistrationRequest",
+ "ListRegistrationsRequest",
+ "ListRegistrationsResponse",
+ "ManagementSettings",
+ "OperationMetadata",
+ "RegisterDomainRequest",
+ "RegisterParameters",
+ "Registration",
+ "ResetAuthorizationCodeRequest",
+ "RetrieveAuthorizationCodeRequest",
+ "RetrieveRegisterParametersRequest",
+ "RetrieveRegisterParametersResponse",
+ "RetrieveTransferParametersRequest",
+ "RetrieveTransferParametersResponse",
+ "SearchDomainsRequest",
+ "SearchDomainsResponse",
+ "TransferDomainRequest",
+ "TransferParameters",
+ "UpdateRegistrationRequest",
+ "ContactNotice",
+ "ContactPrivacy",
+ "DomainNotice",
+ "TransferLockState",
+)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1/types/domains.py b/packages/google-cloud-domains/google/cloud/domains_v1/types/domains.py
new file mode 100644
index 000000000000..266855f41c9a
--- /dev/null
+++ b/packages/google-cloud-domains/google/cloud/domains_v1/types/domains.py
@@ -0,0 +1,986 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import proto # type: ignore
+
+from google.protobuf import field_mask_pb2 # type: ignore
+from google.protobuf import timestamp_pb2 # type: ignore
+from google.type import money_pb2 # type: ignore
+from google.type import postal_address_pb2 # type: ignore
+
+
+__protobuf__ = proto.module(
+ package="google.cloud.domains.v1",
+ manifest={
+ "ContactPrivacy",
+ "DomainNotice",
+ "ContactNotice",
+ "TransferLockState",
+ "Registration",
+ "ManagementSettings",
+ "DnsSettings",
+ "ContactSettings",
+ "SearchDomainsRequest",
+ "SearchDomainsResponse",
+ "RetrieveRegisterParametersRequest",
+ "RetrieveRegisterParametersResponse",
+ "RegisterDomainRequest",
+ "RetrieveTransferParametersRequest",
+ "RetrieveTransferParametersResponse",
+ "TransferDomainRequest",
+ "ListRegistrationsRequest",
+ "ListRegistrationsResponse",
+ "GetRegistrationRequest",
+ "UpdateRegistrationRequest",
+ "ConfigureManagementSettingsRequest",
+ "ConfigureDnsSettingsRequest",
+ "ConfigureContactSettingsRequest",
+ "ExportRegistrationRequest",
+ "DeleteRegistrationRequest",
+ "RetrieveAuthorizationCodeRequest",
+ "ResetAuthorizationCodeRequest",
+ "RegisterParameters",
+ "TransferParameters",
+ "AuthorizationCode",
+ "OperationMetadata",
+ },
+)
+
+
+class ContactPrivacy(proto.Enum):
+ r"""Defines a set of possible contact privacy settings for a
+ ``Registration``.
+
+ `ICANN <https://icann.org/>`__ maintains the WHOIS database, a
+ publicly accessible mapping from domain name to contact information,
+ and requires that each domain name have an entry. Choose from these
+ options to control how much information in your ``ContactSettings``
+ is published.
+ """
+ CONTACT_PRIVACY_UNSPECIFIED = 0
+ PUBLIC_CONTACT_DATA = 1
+ PRIVATE_CONTACT_DATA = 2
+ REDACTED_CONTACT_DATA = 3
+
+
+class DomainNotice(proto.Enum):
+ r"""Notices about special properties of certain domains."""
+ DOMAIN_NOTICE_UNSPECIFIED = 0
+ HSTS_PRELOADED = 1
+
+
+class ContactNotice(proto.Enum):
+ r"""Notices related to contact information."""
+ CONTACT_NOTICE_UNSPECIFIED = 0
+ PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT = 1
+
+
+class TransferLockState(proto.Enum):
+ r"""Possible states of a ``Registration``'s transfer lock."""
+ TRANSFER_LOCK_STATE_UNSPECIFIED = 0
+ UNLOCKED = 1
+ LOCKED = 2
+
+
+class Registration(proto.Message):
+ r"""The ``Registration`` resource facilitates managing and configuring
+ domain name registrations.
+
+ There are several ways to create a new ``Registration`` resource:
+
+ To create a new ``Registration`` resource, find a suitable domain
+ name by calling the ``SearchDomains`` method with a query to see
+ available domain name options. After choosing a name, call
+ ``RetrieveRegisterParameters`` to ensure availability and obtain
+ information like pricing, which is needed to build a call to
+ ``RegisterDomain``.
+
+ Another way to create a new ``Registration`` is to transfer an
+ existing domain from another registrar. First, go to the current
+ registrar to unlock the domain for transfer and retrieve the
+ domain's transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to
+ ``TransferDomain``.
+
+ Attributes:
+ name (str):
+ Output only. Name of the ``Registration`` resource, in the
+ format
+ ``projects/*/locations/*/registrations/<domain_name>``.
+ domain_name (str):
+ Required. Immutable. The domain name. Unicode
+ domain names must be expressed in Punycode
+ format.
+ create_time (google.protobuf.timestamp_pb2.Timestamp):
+ Output only. The creation timestamp of the ``Registration``
+ resource.
+ expire_time (google.protobuf.timestamp_pb2.Timestamp):
+ Output only. The expiration timestamp of the
+ ``Registration``.
+ state (google.cloud.domains_v1.types.Registration.State):
+ Output only. The state of the ``Registration``
+ issues (Sequence[google.cloud.domains_v1.types.Registration.Issue]):
+ Output only. The set of issues with the ``Registration``
+ that require attention.
+ labels (Sequence[google.cloud.domains_v1.types.Registration.LabelsEntry]):
+ Set of labels associated with the ``Registration``.
+ management_settings (google.cloud.domains_v1.types.ManagementSettings):
+ Settings for management of the ``Registration``, including
+ renewal, billing, and transfer. You cannot update these with
+ the ``UpdateRegistration`` method. To update these settings,
+ use the ``ConfigureManagementSettings`` method.
+ dns_settings (google.cloud.domains_v1.types.DnsSettings):
+ Settings controlling the DNS configuration of the
+ ``Registration``. You cannot update these with the
+ ``UpdateRegistration`` method. To update these settings, use
+ the ``ConfigureDnsSettings`` method.
+ contact_settings (google.cloud.domains_v1.types.ContactSettings):
+ Required. Settings for contact information linked to the
+ ``Registration``. You cannot update these with the
+ ``UpdateRegistration`` method. To update these settings, use
+ the ``ConfigureContactSettings`` method.
+ pending_contact_settings (google.cloud.domains_v1.types.ContactSettings):
+ Output only. Pending contact settings for the
+ ``Registration``. Updates to the ``contact_settings`` field
+ that change its ``registrant_contact`` or ``privacy`` fields
+ require email confirmation by the ``registrant_contact``
+ before taking effect. This field is set only if there are
+ pending updates to the ``contact_settings`` that have not
+ been confirmed. To confirm the changes, the
+ ``registrant_contact`` must follow the instructions in the
+ email they receive.
+ supported_privacy (Sequence[google.cloud.domains_v1.types.ContactPrivacy]):
+ Output only. Set of options for the
+ ``contact_settings.privacy`` field that this
+ ``Registration`` supports.
+ """
+
+ class State(proto.Enum):
+ r"""Possible states of a ``Registration``."""
+ STATE_UNSPECIFIED = 0
+ REGISTRATION_PENDING = 1
+ REGISTRATION_FAILED = 2
+ TRANSFER_PENDING = 3
+ TRANSFER_FAILED = 4
+ ACTIVE = 6
+ SUSPENDED = 7
+ EXPORTED = 8
+
+ class Issue(proto.Enum):
+ r"""Possible issues with a ``Registration`` that require attention."""
+ ISSUE_UNSPECIFIED = 0
+ CONTACT_SUPPORT = 1
+ UNVERIFIED_EMAIL = 2
+
+ name = proto.Field(proto.STRING, number=1,)
+ domain_name = proto.Field(proto.STRING, number=2,)
+ create_time = proto.Field(proto.MESSAGE, number=3, message=timestamp_pb2.Timestamp,)
+ expire_time = proto.Field(proto.MESSAGE, number=6, message=timestamp_pb2.Timestamp,)
+ state = proto.Field(proto.ENUM, number=7, enum=State,)
+ issues = proto.RepeatedField(proto.ENUM, number=8, enum=Issue,)
+ labels = proto.MapField(proto.STRING, proto.STRING, number=9,)
+ management_settings = proto.Field(
+ proto.MESSAGE, number=10, message="ManagementSettings",
+ )
+ dns_settings = proto.Field(proto.MESSAGE, number=11, message="DnsSettings",)
+ contact_settings = proto.Field(proto.MESSAGE, number=12, message="ContactSettings",)
+ pending_contact_settings = proto.Field(
+ proto.MESSAGE, number=13, message="ContactSettings",
+ )
+ supported_privacy = proto.RepeatedField(
+ proto.ENUM, number=14, enum="ContactPrivacy",
+ )
+
+
+class ManagementSettings(proto.Message):
+ r"""Defines renewal, billing, and transfer settings for a
+ ``Registration``.
+
+ Attributes:
+ renewal_method (google.cloud.domains_v1.types.ManagementSettings.RenewalMethod):
+ Output only. The renewal method for this ``Registration``.
+ transfer_lock_state (google.cloud.domains_v1.types.TransferLockState):
+ Controls whether the domain can be
+ transferred to another registrar.
+ """
+
+ class RenewalMethod(proto.Enum):
+ r"""Defines how the ``Registration`` is renewed."""
+ RENEWAL_METHOD_UNSPECIFIED = 0
+ AUTOMATIC_RENEWAL = 1
+ MANUAL_RENEWAL = 2
+
+ renewal_method = proto.Field(proto.ENUM, number=3, enum=RenewalMethod,)
+ transfer_lock_state = proto.Field(proto.ENUM, number=4, enum="TransferLockState",)
+
+
+class DnsSettings(proto.Message):
+ r"""Defines the DNS configuration of a ``Registration``, including name
+ servers, DNSSEC, and glue records.
+
+ Attributes:
+ custom_dns (google.cloud.domains_v1.types.DnsSettings.CustomDns):
+ An arbitrary DNS provider identified by its
+ name servers.
+ google_domains_dns (google.cloud.domains_v1.types.DnsSettings.GoogleDomainsDns):
+ The free DNS zone provided by `Google
+ Domains <https://domains.google/>`__.
+ glue_records (Sequence[google.cloud.domains_v1.types.DnsSettings.GlueRecord]):
+ The list of glue records for this ``Registration``. Commonly
+ empty.
+ """
+
+ class DsState(proto.Enum):
+ r"""The publication state of DS records for a ``Registration``."""
+ DS_STATE_UNSPECIFIED = 0
+ DS_RECORDS_UNPUBLISHED = 1
+ DS_RECORDS_PUBLISHED = 2
+
+ class CustomDns(proto.Message):
+ r"""Configuration for an arbitrary DNS provider.
+
+ Attributes:
+ name_servers (Sequence[str]):
+ Required. A list of name servers that store
+ the DNS zone for this domain. Each name server
+ is a domain name, with Unicode domain names
+ expressed in Punycode format.
+ ds_records (Sequence[google.cloud.domains_v1.types.DnsSettings.DsRecord]):
+ The list of DS records for this domain, which
+ are used to enable DNSSEC. The domain's DNS
+ provider can provide the values to set here. If
+ this field is empty, DNSSEC is disabled.
+ """
+
+ name_servers = proto.RepeatedField(proto.STRING, number=1,)
+ ds_records = proto.RepeatedField(
+ proto.MESSAGE, number=2, message="DnsSettings.DsRecord",
+ )
+
+ class GoogleDomainsDns(proto.Message):
+ r"""Configuration for using the free DNS zone provided by Google Domains
+ as a ``Registration``'s ``dns_provider``. You cannot configure the
+ DNS zone itself using the API. To configure the DNS zone, go to
+ `Google Domains <https://domains.google/>`__.
+
+ Attributes:
+ name_servers (Sequence[str]):
+ Output only. A list of name servers that
+ store the DNS zone for this domain. Each name
+ server is a domain name, with Unicode domain
+ names expressed in Punycode format. This field
+ is automatically populated with the name servers
+ assigned to the Google Domains DNS zone.
+ ds_state (google.cloud.domains_v1.types.DnsSettings.DsState):
+ Required. The state of DS records for this
+ domain. Used to enable or disable automatic
+ DNSSEC.
+ ds_records (Sequence[google.cloud.domains_v1.types.DnsSettings.DsRecord]):
+ Output only. The list of DS records published for this
+ domain. The list is automatically populated when
+ ``ds_state`` is ``DS_RECORDS_PUBLISHED``, otherwise it
+ remains empty.
+ """
+
+ name_servers = proto.RepeatedField(proto.STRING, number=1,)
+ ds_state = proto.Field(proto.ENUM, number=2, enum="DnsSettings.DsState",)
+ ds_records = proto.RepeatedField(
+ proto.MESSAGE, number=3, message="DnsSettings.DsRecord",
+ )
+
+ class DsRecord(proto.Message):
+ r"""Defines a Delegation Signer (DS) record, which is needed to
+ enable DNSSEC for a domain. It contains a digest (hash) of a
+ DNSKEY record that must be present in the domain's DNS zone.
+
+ Attributes:
+ key_tag (int):
+ The key tag of the record. Must be set in
+ range 0 -- 65535.
+ algorithm (google.cloud.domains_v1.types.DnsSettings.DsRecord.Algorithm):
+ The algorithm used to generate the referenced
+ DNSKEY.
+ digest_type (google.cloud.domains_v1.types.DnsSettings.DsRecord.DigestType):
+ The hash function used to generate the digest
+ of the referenced DNSKEY.
+ digest (str):
+ The digest generated from the referenced
+ DNSKEY.
+ """
+
+ class Algorithm(proto.Enum):
+ r"""List of algorithms used to create a DNSKEY. Certain
+ algorithms are not supported for particular domains.
+ """
+ ALGORITHM_UNSPECIFIED = 0
+ RSAMD5 = 1
+ DH = 2
+ DSA = 3
+ ECC = 4
+ RSASHA1 = 5
+ DSANSEC3SHA1 = 6
+ RSASHA1NSEC3SHA1 = 7
+ RSASHA256 = 8
+ RSASHA512 = 10
+ ECCGOST = 12
+ ECDSAP256SHA256 = 13
+ ECDSAP384SHA384 = 14
+ ED25519 = 15
+ ED448 = 16
+ INDIRECT = 252
+ PRIVATEDNS = 253
+ PRIVATEOID = 254
+
+ class DigestType(proto.Enum):
+ r"""List of hash functions that may have been used to generate a
+ digest of a DNSKEY.
+ """
+ DIGEST_TYPE_UNSPECIFIED = 0
+ SHA1 = 1
+ SHA256 = 2
+ GOST3411 = 3
+ SHA384 = 4
+
+ key_tag = proto.Field(proto.INT32, number=1,)
+ algorithm = proto.Field(
+ proto.ENUM, number=2, enum="DnsSettings.DsRecord.Algorithm",
+ )
+ digest_type = proto.Field(
+ proto.ENUM, number=3, enum="DnsSettings.DsRecord.DigestType",
+ )
+ digest = proto.Field(proto.STRING, number=4,)
+
+ class GlueRecord(proto.Message):
+ r"""Defines a host on your domain that is a DNS name server for your
+ domain and/or other domains. Glue records are a way of making the IP
+ address of a name server known, even when it serves DNS queries for
+ its parent domain. For example, when ``ns.example.com`` is a name
+ server for ``example.com``, the host ``ns.example.com`` must have a
+ glue record to break the circular DNS reference.
+
+ Attributes:
+ host_name (str):
+ Required. Domain name of the host in Punycode
+ format.
+ ipv4_addresses (Sequence[str]):
+ List of IPv4 addresses corresponding to this host in the
+ standard decimal format (e.g. ``198.51.100.1``). At least
+ one of ``ipv4_address`` and ``ipv6_address`` must be set.
+ ipv6_addresses (Sequence[str]):
+ List of IPv6 addresses corresponding to this host in the
+ standard hexadecimal format (e.g. ``2001:db8::``). At least
+ one of ``ipv4_address`` and ``ipv6_address`` must be set.
+ """
+
+ host_name = proto.Field(proto.STRING, number=1,)
+ ipv4_addresses = proto.RepeatedField(proto.STRING, number=2,)
+ ipv6_addresses = proto.RepeatedField(proto.STRING, number=3,)
+
+ custom_dns = proto.Field(
+ proto.MESSAGE, number=1, oneof="dns_provider", message=CustomDns,
+ )
+ google_domains_dns = proto.Field(
+ proto.MESSAGE, number=2, oneof="dns_provider", message=GoogleDomainsDns,
+ )
+ glue_records = proto.RepeatedField(proto.MESSAGE, number=4, message=GlueRecord,)
+
+
+class ContactSettings(proto.Message):
+ r"""Defines the contact information associated with a ``Registration``.
+
+ `ICANN <https://icann.org/>`__ requires all domain names to have
+ associated contact information. The ``registrant_contact`` is
+ considered the domain's legal owner, and often the other contacts
+ are identical.
+
+ Attributes:
+ privacy (google.cloud.domains_v1.types.ContactPrivacy):
+ Required. Privacy setting for the contacts associated with
+ the ``Registration``.
+ registrant_contact (google.cloud.domains_v1.types.ContactSettings.Contact):
+ Required. The registrant contact for the ``Registration``.
+
+ *Caution: Anyone with access to this email address, phone
+ number, and/or postal address can take control of the
+ domain.*
+
+ *Warning: For new ``Registration``\ s, the registrant
+ receives an email confirmation that they must complete
+ within 15 days to avoid domain suspension.*
+ admin_contact (google.cloud.domains_v1.types.ContactSettings.Contact):
+ Required. The administrative contact for the
+ ``Registration``.
+ technical_contact (google.cloud.domains_v1.types.ContactSettings.Contact):
+ Required. The technical contact for the ``Registration``.
+ """
+
+ class Contact(proto.Message):
+ r"""Details required for a contact associated with a ``Registration``.
+
+ Attributes:
+ postal_address (google.type.postal_address_pb2.PostalAddress):
+ Required. Postal address of the contact.
+ email (str):
+ Required. Email address of the contact.
+ phone_number (str):
+ Required. Phone number of the contact in international
+ format. For example, ``"+1-800-555-0123"``.
+ fax_number (str):
+ Fax number of the contact in international format. For
+ example, ``"+1-800-555-0123"``.
+ """
+
+ postal_address = proto.Field(
+ proto.MESSAGE, number=1, message=postal_address_pb2.PostalAddress,
+ )
+ email = proto.Field(proto.STRING, number=2,)
+ phone_number = proto.Field(proto.STRING, number=3,)
+ fax_number = proto.Field(proto.STRING, number=4,)
+
+ privacy = proto.Field(proto.ENUM, number=1, enum="ContactPrivacy",)
+ registrant_contact = proto.Field(proto.MESSAGE, number=2, message=Contact,)
+ admin_contact = proto.Field(proto.MESSAGE, number=3, message=Contact,)
+ technical_contact = proto.Field(proto.MESSAGE, number=4, message=Contact,)
+
+
+class SearchDomainsRequest(proto.Message):
+ r"""Request for the ``SearchDomains`` method.
+
+ Attributes:
+ query (str):
+ Required. String used to search for available
+ domain names.
+ location (str):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+ """
+
+ query = proto.Field(proto.STRING, number=1,)
+ location = proto.Field(proto.STRING, number=2,)
+
+
+class SearchDomainsResponse(proto.Message):
+ r"""Response for the ``SearchDomains`` method.
+
+ Attributes:
+ register_parameters (Sequence[google.cloud.domains_v1.types.RegisterParameters]):
+ Results of the domain name search.
+ """
+
+ register_parameters = proto.RepeatedField(
+ proto.MESSAGE, number=1, message="RegisterParameters",
+ )
+
+
+class RetrieveRegisterParametersRequest(proto.Message):
+ r"""Request for the ``RetrieveRegisterParameters`` method.
+
+ Attributes:
+ domain_name (str):
+ Required. The domain name. Unicode domain
+ names must be expressed in Punycode format.
+ location (str):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+ """
+
+ domain_name = proto.Field(proto.STRING, number=1,)
+ location = proto.Field(proto.STRING, number=2,)
+
+
+class RetrieveRegisterParametersResponse(proto.Message):
+ r"""Response for the ``RetrieveRegisterParameters`` method.
+
+ Attributes:
+ register_parameters (google.cloud.domains_v1.types.RegisterParameters):
+ Parameters to use when calling the ``RegisterDomain``
+ method.
+ """
+
+ register_parameters = proto.Field(
+ proto.MESSAGE, number=1, message="RegisterParameters",
+ )
+
+
+class RegisterDomainRequest(proto.Message):
+ r"""Request for the ``RegisterDomain`` method.
+
+ Attributes:
+ parent (str):
+ Required. The parent resource of the ``Registration``. Must
+ be in the format ``projects/*/locations/*``.
+ registration (google.cloud.domains_v1.types.Registration):
+ Required. The complete ``Registration`` resource to be
+ created.
+ domain_notices (Sequence[google.cloud.domains_v1.types.DomainNotice]):
+ The list of domain notices that you acknowledge. Call
+ ``RetrieveRegisterParameters`` to see the notices that need
+ acknowledgement.
+ contact_notices (Sequence[google.cloud.domains_v1.types.ContactNotice]):
+ The list of contact notices that the caller acknowledges.
+ The notices needed here depend on the values specified in
+ ``registration.contact_settings``.
+ yearly_price (google.type.money_pb2.Money):
+ Required. Yearly price to register or renew
+ the domain. The value that should be put here
+ can be obtained from RetrieveRegisterParameters
+ or SearchDomains calls.
+ validate_only (bool):
+ When true, only validation is performed, without actually
+ registering the domain. Follows:
+ https://cloud.google.com/apis/design/design_patterns#request_validation
+ """
+
+ parent = proto.Field(proto.STRING, number=1,)
+ registration = proto.Field(proto.MESSAGE, number=2, message="Registration",)
+ domain_notices = proto.RepeatedField(proto.ENUM, number=3, enum="DomainNotice",)
+ contact_notices = proto.RepeatedField(proto.ENUM, number=4, enum="ContactNotice",)
+ yearly_price = proto.Field(proto.MESSAGE, number=5, message=money_pb2.Money,)
+ validate_only = proto.Field(proto.BOOL, number=6,)
+
+
+class RetrieveTransferParametersRequest(proto.Message):
+ r"""Request for the ``RetrieveTransferParameters`` method.
+
+ Attributes:
+ domain_name (str):
+ Required. The domain name. Unicode domain
+ names must be expressed in Punycode format.
+ location (str):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+ """
+
+ domain_name = proto.Field(proto.STRING, number=1,)
+ location = proto.Field(proto.STRING, number=2,)
+
+
+class RetrieveTransferParametersResponse(proto.Message):
+ r"""Response for the ``RetrieveTransferParameters`` method.
+
+ Attributes:
+ transfer_parameters (google.cloud.domains_v1.types.TransferParameters):
+ Parameters to use when calling the ``TransferDomain``
+ method.
+ """
+
+ transfer_parameters = proto.Field(
+ proto.MESSAGE, number=1, message="TransferParameters",
+ )
+
+
+class TransferDomainRequest(proto.Message):
+ r"""Request for the ``TransferDomain`` method.
+
+ Attributes:
+ parent (str):
+ Required. The parent resource of the ``Registration``. Must
+ be in the format ``projects/*/locations/*``.
+ registration (google.cloud.domains_v1.types.Registration):
+ Required. The complete ``Registration`` resource to be
+ created.
+
+ You can leave ``registration.dns_settings`` unset to import
+ the domain's current DNS configuration from its current
+ registrar. Use this option only if you are sure that the
+ domain's current DNS service does not cease upon transfer,
+ as is often the case for DNS services provided for free by
+ the registrar.
+ contact_notices (Sequence[google.cloud.domains_v1.types.ContactNotice]):
+ The list of contact notices that you acknowledge. The
+ notices needed here depend on the values specified in
+ ``registration.contact_settings``.
+ yearly_price (google.type.money_pb2.Money):
+ Required. Acknowledgement of the price to transfer or renew
+ the domain for one year. Call ``RetrieveTransferParameters``
+ to obtain the price, which you must acknowledge.
+ authorization_code (google.cloud.domains_v1.types.AuthorizationCode):
+ The domain's transfer authorization code. You
+ can obtain this from the domain's current
+ registrar.
+ validate_only (bool):
+ Validate the request without actually
+ transferring the domain.
+ """
+
+ parent = proto.Field(proto.STRING, number=1,)
+ registration = proto.Field(proto.MESSAGE, number=2, message="Registration",)
+ contact_notices = proto.RepeatedField(proto.ENUM, number=3, enum="ContactNotice",)
+ yearly_price = proto.Field(proto.MESSAGE, number=4, message=money_pb2.Money,)
+ authorization_code = proto.Field(
+ proto.MESSAGE, number=5, message="AuthorizationCode",
+ )
+ validate_only = proto.Field(proto.BOOL, number=6,)
+
+
+class ListRegistrationsRequest(proto.Message):
+ r"""Request for the ``ListRegistrations`` method.
+
+ Attributes:
+ parent (str):
+ Required. The project and location from which to list
+ ``Registration``\ s, specified in the format
+ ``projects/*/locations/*``.
+ page_size (int):
+ Maximum number of results to return.
+ page_token (str):
+ When set to the ``next_page_token`` from a prior response,
+ provides the next page of results.
+ filter (str):
+ Filter expression to restrict the ``Registration``\ s
+ returned.
+
+ The expression must specify the field name, a comparison
+ operator, and the value that you want to use for filtering.
+ The value must be a string, a number, a boolean, or an enum
+ value. The comparison operator should be one of =, !=, >, <,
+ >=, <=, or : for prefix or wildcard matches.
+
+ For example, to filter to a specific domain name, use an
+ expression like ``domainName="example.com"``. You can also
+ check for the existence of a field; for example, to find
+ domains using custom DNS settings, use an expression like
+ ``dnsSettings.customDns:*``.
+
+ You can also create compound filters by combining
+ expressions with the ``AND`` and ``OR`` operators. For
+ example, to find domains that are suspended or have specific
+ issues flagged, use an expression like
+ ``(state=SUSPENDED) OR (issue:*)``.
+ """
+
+ parent = proto.Field(proto.STRING, number=1,)
+ page_size = proto.Field(proto.INT32, number=2,)
+ page_token = proto.Field(proto.STRING, number=3,)
+ filter = proto.Field(proto.STRING, number=4,)
+
+
+class ListRegistrationsResponse(proto.Message):
+ r"""Response for the ``ListRegistrations`` method.
+
+ Attributes:
+ registrations (Sequence[google.cloud.domains_v1.types.Registration]):
+ A list of ``Registration``\ s.
+ next_page_token (str):
+ When present, there are more results to retrieve. Set
+ ``page_token`` to this value on a subsequent call to get the
+ next page of results.
+ """
+
+ @property
+ def raw_page(self):
+ return self
+
+ registrations = proto.RepeatedField(
+ proto.MESSAGE, number=1, message="Registration",
+ )
+ next_page_token = proto.Field(proto.STRING, number=2,)
+
+
+class GetRegistrationRequest(proto.Message):
+ r"""Request for the ``GetRegistration`` method.
+
+ Attributes:
+ name (str):
+ Required. The name of the ``Registration`` to get, in the
+ format ``projects/*/locations/*/registrations/*``.
+ """
+
+ name = proto.Field(proto.STRING, number=1,)
+
+
+class UpdateRegistrationRequest(proto.Message):
+ r"""Request for the ``UpdateRegistration`` method.
+
+ Attributes:
+ registration (google.cloud.domains_v1.types.Registration):
+ Fields of the ``Registration`` to update.
+ update_mask (google.protobuf.field_mask_pb2.FieldMask):
+ Required. The field mask describing which fields to update
+ as a comma-separated list. For example, if only the labels
+ are being updated, the ``update_mask`` is ``"labels"``.
+ """
+
+ registration = proto.Field(proto.MESSAGE, number=1, message="Registration",)
+ update_mask = proto.Field(
+ proto.MESSAGE, number=2, message=field_mask_pb2.FieldMask,
+ )
+
+
+class ConfigureManagementSettingsRequest(proto.Message):
+ r"""Request for the ``ConfigureManagementSettings`` method.
+
+ Attributes:
+ registration (str):
+ Required. The name of the ``Registration`` whose management
+ settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+ management_settings (google.cloud.domains_v1.types.ManagementSettings):
+ Fields of the ``ManagementSettings`` to update.
+ update_mask (google.protobuf.field_mask_pb2.FieldMask):
+ Required. The field mask describing which fields to update
+ as a comma-separated list. For example, if only the transfer
+ lock is being updated, the ``update_mask`` is
+ ``"transfer_lock_state"``.
+ """
+
+ registration = proto.Field(proto.STRING, number=1,)
+ management_settings = proto.Field(
+ proto.MESSAGE, number=2, message="ManagementSettings",
+ )
+ update_mask = proto.Field(
+ proto.MESSAGE, number=3, message=field_mask_pb2.FieldMask,
+ )
+
+
+class ConfigureDnsSettingsRequest(proto.Message):
+ r"""Request for the ``ConfigureDnsSettings`` method.
+
+ Attributes:
+ registration (str):
+ Required. The name of the ``Registration`` whose DNS
+ settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+ dns_settings (google.cloud.domains_v1.types.DnsSettings):
+ Fields of the ``DnsSettings`` to update.
+ update_mask (google.protobuf.field_mask_pb2.FieldMask):
+ Required. The field mask describing which fields to update
+ as a comma-separated list. For example, if only the name
+ servers are being updated for an existing Custom DNS
+ configuration, the ``update_mask`` is
+ ``"custom_dns.name_servers"``.
+
+ When changing the DNS provider from one type to another,
+ pass the new provider's field name as part of the field
+ mask. For example, when changing from a Google Domains DNS
+ configuration to a Custom DNS configuration, the
+ ``update_mask`` is ``"custom_dns"``. //
+ validate_only (bool):
+ Validate the request without actually
+ updating the DNS settings.
+ """
+
+ registration = proto.Field(proto.STRING, number=1,)
+ dns_settings = proto.Field(proto.MESSAGE, number=2, message="DnsSettings",)
+ update_mask = proto.Field(
+ proto.MESSAGE, number=3, message=field_mask_pb2.FieldMask,
+ )
+ validate_only = proto.Field(proto.BOOL, number=4,)
+
+
+class ConfigureContactSettingsRequest(proto.Message):
+ r"""Request for the ``ConfigureContactSettings`` method.
+
+ Attributes:
+ registration (str):
+ Required. The name of the ``Registration`` whose contact
+ settings are being updated, in the format
+ ``projects/*/locations/*/registrations/*``.
+ contact_settings (google.cloud.domains_v1.types.ContactSettings):
+ Fields of the ``ContactSettings`` to update.
+ update_mask (google.protobuf.field_mask_pb2.FieldMask):
+ Required. The field mask describing which fields to update
+ as a comma-separated list. For example, if only the
+ registrant contact is being updated, the ``update_mask`` is
+ ``"registrant_contact"``.
+ contact_notices (Sequence[google.cloud.domains_v1.types.ContactNotice]):
+ The list of contact notices that the caller acknowledges.
+ The notices needed here depend on the values specified in
+ ``contact_settings``.
+ validate_only (bool):
+ Validate the request without actually
+ updating the contact settings.
+ """
+
+ registration = proto.Field(proto.STRING, number=1,)
+ contact_settings = proto.Field(proto.MESSAGE, number=2, message="ContactSettings",)
+ update_mask = proto.Field(
+ proto.MESSAGE, number=3, message=field_mask_pb2.FieldMask,
+ )
+ contact_notices = proto.RepeatedField(proto.ENUM, number=4, enum="ContactNotice",)
+ validate_only = proto.Field(proto.BOOL, number=5,)
+
+
+class ExportRegistrationRequest(proto.Message):
+ r"""Request for the ``ExportRegistration`` method.
+
+ Attributes:
+ name (str):
+ Required. The name of the ``Registration`` to export, in the
+ format ``projects/*/locations/*/registrations/*``.
+ """
+
+ name = proto.Field(proto.STRING, number=1,)
+
+
+class DeleteRegistrationRequest(proto.Message):
+ r"""Request for the ``DeleteRegistration`` method.
+
+ Attributes:
+ name (str):
+ Required. The name of the ``Registration`` to delete, in the
+ format ``projects/*/locations/*/registrations/*``.
+ """
+
+ name = proto.Field(proto.STRING, number=1,)
+
+
+class RetrieveAuthorizationCodeRequest(proto.Message):
+ r"""Request for the ``RetrieveAuthorizationCode`` method.
+
+ Attributes:
+ registration (str):
+ Required. The name of the ``Registration`` whose
+ authorization code is being retrieved, in the format
+ ``projects/*/locations/*/registrations/*``.
+ """
+
+ registration = proto.Field(proto.STRING, number=1,)
+
+
+class ResetAuthorizationCodeRequest(proto.Message):
+ r"""Request for the ``ResetAuthorizationCode`` method.
+
+ Attributes:
+ registration (str):
+ Required. The name of the ``Registration`` whose
+ authorization code is being reset, in the format
+ ``projects/*/locations/*/registrations/*``.
+ """
+
+ registration = proto.Field(proto.STRING, number=1,)
+
+
+class RegisterParameters(proto.Message):
+ r"""Parameters required to register a new domain.
+
+ Attributes:
+ domain_name (str):
+ The domain name. Unicode domain names are
+ expressed in Punycode format.
+ availability (google.cloud.domains_v1.types.RegisterParameters.Availability):
+ Indicates whether the domain is available for registration.
+ This value is accurate when obtained by calling
+ ``RetrieveRegisterParameters``, but is approximate when
+ obtained by calling ``SearchDomains``.
+ supported_privacy (Sequence[google.cloud.domains_v1.types.ContactPrivacy]):
+ Contact privacy options that the domain
+ supports.
+ domain_notices (Sequence[google.cloud.domains_v1.types.DomainNotice]):
+ Notices about special properties of the
+ domain.
+ yearly_price (google.type.money_pb2.Money):
+ Price to register or renew the domain for one
+ year.
+ """
+
+ class Availability(proto.Enum):
+ r"""Possible availability states of a domain name."""
+ AVAILABILITY_UNSPECIFIED = 0
+ AVAILABLE = 1
+ UNAVAILABLE = 2
+ UNSUPPORTED = 3
+ UNKNOWN = 4
+
+ domain_name = proto.Field(proto.STRING, number=1,)
+ availability = proto.Field(proto.ENUM, number=2, enum=Availability,)
+ supported_privacy = proto.RepeatedField(
+ proto.ENUM, number=3, enum="ContactPrivacy",
+ )
+ domain_notices = proto.RepeatedField(proto.ENUM, number=4, enum="DomainNotice",)
+ yearly_price = proto.Field(proto.MESSAGE, number=5, message=money_pb2.Money,)
+
+
+class TransferParameters(proto.Message):
+ r"""Parameters required to transfer a domain from another
+ registrar.
+
+ Attributes:
+ domain_name (str):
+ The domain name. Unicode domain names are
+ expressed in Punycode format.
+ current_registrar (str):
+ The registrar that currently manages the
+ domain.
+ name_servers (Sequence[str]):
+ The name servers that currently store the
+ configuration of the domain.
+ transfer_lock_state (google.cloud.domains_v1.types.TransferLockState):
+ Indicates whether the domain is protected by a transfer
+ lock. For a transfer to succeed, this must show
+ ``UNLOCKED``. To unlock a domain, go to its current
+ registrar.
+ supported_privacy (Sequence[google.cloud.domains_v1.types.ContactPrivacy]):
+ Contact privacy options that the domain
+ supports.
+ yearly_price (google.type.money_pb2.Money):
+ Price to transfer or renew the domain for one
+ year.
+ """
+
+ domain_name = proto.Field(proto.STRING, number=1,)
+ current_registrar = proto.Field(proto.STRING, number=2,)
+ name_servers = proto.RepeatedField(proto.STRING, number=3,)
+ transfer_lock_state = proto.Field(proto.ENUM, number=4, enum="TransferLockState",)
+ supported_privacy = proto.RepeatedField(
+ proto.ENUM, number=5, enum="ContactPrivacy",
+ )
+ yearly_price = proto.Field(proto.MESSAGE, number=6, message=money_pb2.Money,)
+
+
+class AuthorizationCode(proto.Message):
+ r"""Defines an authorization code.
+
+ Attributes:
+ code (str):
+ The Authorization Code in ASCII. It can be
+ used to transfer the domain to or from another
+ registrar.
+ """
+
+ code = proto.Field(proto.STRING, number=1,)
+
+
+class OperationMetadata(proto.Message):
+ r"""Represents the metadata of the long-running operation. Output
+ only.
+
+ Attributes:
+ create_time (google.protobuf.timestamp_pb2.Timestamp):
+ The time the operation was created.
+ end_time (google.protobuf.timestamp_pb2.Timestamp):
+ The time the operation finished running.
+ target (str):
+ Server-defined resource path for the target
+ of the operation.
+ verb (str):
+ Name of the verb executed by the operation.
+ status_detail (str):
+ Human-readable status of the operation, if
+ any.
+ api_version (str):
+ API version used to start the operation.
+ """
+
+ create_time = proto.Field(proto.MESSAGE, number=1, message=timestamp_pb2.Timestamp,)
+ end_time = proto.Field(proto.MESSAGE, number=2, message=timestamp_pb2.Timestamp,)
+ target = proto.Field(proto.STRING, number=3,)
+ verb = proto.Field(proto.STRING, number=4,)
+ status_detail = proto.Field(proto.STRING, number=5,)
+ api_version = proto.Field(proto.STRING, number=6,)
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/__init__.py b/packages/google-cloud-domains/google/cloud/domains_v1beta1/__init__.py
index 7e9ede1a6a6b..10f29836861d 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/__init__.py
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/__init__.py
@@ -37,8 +37,12 @@
from .types.domains import RetrieveAuthorizationCodeRequest
from .types.domains import RetrieveRegisterParametersRequest
from .types.domains import RetrieveRegisterParametersResponse
+from .types.domains import RetrieveTransferParametersRequest
+from .types.domains import RetrieveTransferParametersResponse
from .types.domains import SearchDomainsRequest
from .types.domains import SearchDomainsResponse
+from .types.domains import TransferDomainRequest
+from .types.domains import TransferParameters
from .types.domains import UpdateRegistrationRequest
from .types.domains import ContactNotice
from .types.domains import ContactPrivacy
@@ -71,8 +75,12 @@
"RetrieveAuthorizationCodeRequest",
"RetrieveRegisterParametersRequest",
"RetrieveRegisterParametersResponse",
+ "RetrieveTransferParametersRequest",
+ "RetrieveTransferParametersResponse",
"SearchDomainsRequest",
"SearchDomainsResponse",
+ "TransferDomainRequest",
"TransferLockState",
+ "TransferParameters",
"UpdateRegistrationRequest",
)
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/gapic_metadata.json b/packages/google-cloud-domains/google/cloud/domains_v1beta1/gapic_metadata.json
index dd052529c00e..c6f9a69f5d74 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/gapic_metadata.json
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/gapic_metadata.json
@@ -65,11 +65,21 @@
"retrieve_register_parameters"
]
},
+ "RetrieveTransferParameters": {
+ "methods": [
+ "retrieve_transfer_parameters"
+ ]
+ },
"SearchDomains": {
"methods": [
"search_domains"
]
},
+ "TransferDomain": {
+ "methods": [
+ "transfer_domain"
+ ]
+ },
"UpdateRegistration": {
"methods": [
"update_registration"
@@ -135,11 +145,21 @@
"retrieve_register_parameters"
]
},
+ "RetrieveTransferParameters": {
+ "methods": [
+ "retrieve_transfer_parameters"
+ ]
+ },
"SearchDomains": {
"methods": [
"search_domains"
]
},
+ "TransferDomain": {
+ "methods": [
+ "transfer_domain"
+ ]
+ },
"UpdateRegistration": {
"methods": [
"update_registration"
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/async_client.py b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/async_client.py
index 05b829c573ea..4deada9e099b 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/async_client.py
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/async_client.py
@@ -394,6 +394,9 @@ async def register_domain(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -402,6 +405,15 @@ async def register_domain(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -452,6 +464,256 @@ async def register_domain(
# Done; return the response.
return response
+ async def retrieve_transfer_parameters(
+ self,
+ request: domains.RetrieveTransferParametersRequest = None,
+ *,
+ location: str = None,
+ domain_name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.RetrieveTransferParametersResponse:
+ r"""Gets parameters needed to transfer a domain name from another
+ registrar to Cloud Domains. For domains managed by Google
+ Domains, transferring to Cloud Domains is not supported.
+
+ Use the returned values to call ``TransferDomain``.
+
+ Args:
+ request (:class:`google.cloud.domains_v1beta1.types.RetrieveTransferParametersRequest`):
+ The request object. Request for the
+ `RetrieveTransferParameters` method.
+ location (:class:`str`):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``location`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ domain_name (:class:`str`):
+ Required. The domain name. Unicode
+ domain names must be expressed in
+ Punycode format.
+
+ This corresponds to the ``domain_name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1beta1.types.RetrieveTransferParametersResponse:
+ Response for the RetrieveTransferParameters method.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([location, domain_name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.RetrieveTransferParametersRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if location is not None:
+ request.location = location
+ if domain_name is not None:
+ request.domain_name = domain_name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.retrieve_transfer_parameters,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ async def transfer_domain(
+ self,
+ request: domains.TransferDomainRequest = None,
+ *,
+ parent: str = None,
+ registration: domains.Registration = None,
+ yearly_price: money_pb2.Money = None,
+ authorization_code: domains.AuthorizationCode = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation_async.AsyncOperation:
+ r"""Transfers a domain name from another registrar to Cloud Domains.
+ For domains managed by Google Domains, transferring to Cloud
+ Domains is not supported.
+
+ Before calling this method, go to the domain's current registrar
+ to unlock the domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to this
+ method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``TRANSFER_PENDING``. It can take several days to complete the
+ transfer process. The registrant can often speed up this process
+ by approving the transfer through the current registrar, either
+ by clicking a link in an email from the registrar or by visiting
+ the registrar's website.
+
+ A few minutes after transfer approval, the resource transitions
+ to state ``ACTIVE``, indicating that the transfer was
+ successful. If the transfer is rejected or the request expires
+ without being approved, the resource can end up in state
+ ``TRANSFER_FAILED``. If transfer fails, you can safely delete
+ the resource and retry the transfer.
+
+ Args:
+ request (:class:`google.cloud.domains_v1beta1.types.TransferDomainRequest`):
+ The request object. Request for the `TransferDomain`
+ method.
+ parent (:class:`str`):
+ Required. The parent resource of the ``Registration``.
+ Must be in the format ``projects/*/locations/*``.
+
+ This corresponds to the ``parent`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ registration (:class:`google.cloud.domains_v1beta1.types.Registration`):
+ Required. The complete ``Registration`` resource to be
+ created.
+
+ You can leave ``registration.dns_settings`` unset to
+ import the domain's current DNS configuration from its
+ current registrar. Use this option only if you are sure
+ that the domain's current DNS service does not cease
+ upon transfer, as is often the case for DNS services
+ provided for free by the registrar.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ yearly_price (:class:`google.type.money_pb2.Money`):
+ Required. Acknowledgement of the price to transfer or
+ renew the domain for one year. Call
+ ``RetrieveTransferParameters`` to obtain the price,
+ which you must acknowledge.
+
+ This corresponds to the ``yearly_price`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ authorization_code (:class:`google.cloud.domains_v1beta1.types.AuthorizationCode`):
+ The domain's transfer authorization
+ code. You can obtain this from the
+ domain's current registrar.
+
+ This corresponds to the ``authorization_code`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation_async.AsyncOperation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any(
+ [parent, registration, yearly_price, authorization_code]
+ )
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ request = domains.TransferDomainRequest(request)
+
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if parent is not None:
+ request.parent = parent
+ if registration is not None:
+ request.registration = registration
+ if yearly_price is not None:
+ request.yearly_price = yearly_price
+ if authorization_code is not None:
+ request.authorization_code = authorization_code
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = gapic_v1.method_async.wrap_method(
+ self._client._transport.transfer_domain,
+ default_timeout=None,
+ client_info=DEFAULT_CLIENT_INFO,
+ )
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+ )
+
+ # Send the request.
+ response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation_async.from_gapic(
+ response,
+ self._client._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
async def list_registrations(
self,
request: domains.ListRegistrationsRequest = None,
@@ -565,6 +827,9 @@ async def get_registration(
The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -573,6 +838,15 @@ async def get_registration(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -643,8 +917,8 @@ async def update_registration(
update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`):
Required. The field mask describing which fields to
update as a comma-separated list. For example, if only
- the labels are being updated, the ``update_mask`` would
- be ``"labels"``.
+ the labels are being updated, the ``update_mask`` is
+ ``"labels"``.
This corresponds to the ``update_mask`` field
on the ``request`` instance; if ``request`` is provided, this
@@ -662,6 +936,9 @@ async def update_registration(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -670,6 +947,15 @@ async def update_registration(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -754,7 +1040,7 @@ async def configure_management_settings(
Required. The field mask describing which fields to
update as a comma-separated list. For example, if only
the transfer lock is being updated, the ``update_mask``
- would be ``"transfer_lock_state"``.
+ is ``"transfer_lock_state"``.
This corresponds to the ``update_mask`` field
on the ``request`` instance; if ``request`` is provided, this
@@ -772,6 +1058,9 @@ async def configure_management_settings(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -780,6 +1069,15 @@ async def configure_management_settings(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -866,14 +1164,14 @@ async def configure_dns_settings(
Required. The field mask describing which fields to
update as a comma-separated list. For example, if only
the name servers are being updated for an existing
- Custom DNS configuration, the ``update_mask`` would be
+ Custom DNS configuration, the ``update_mask`` is
``"custom_dns.name_servers"``.
When changing the DNS provider from one type to another,
pass the new provider's field name as part of the field
mask. For example, when changing from a Google Domains
DNS configuration to a Custom DNS configuration, the
- ``update_mask`` would be ``"custom_dns"``. //
+ ``update_mask`` is ``"custom_dns"``. //
This corresponds to the ``update_mask`` field
on the ``request`` instance; if ``request`` is provided, this
@@ -891,6 +1189,9 @@ async def configure_dns_settings(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -899,6 +1200,15 @@ async def configure_dns_settings(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -986,7 +1296,7 @@ async def configure_contact_settings(
Required. The field mask describing which fields to
update as a comma-separated list. For example, if only
the registrant contact is being updated, the
- ``update_mask`` would be ``"registrant_contact"``.
+ ``update_mask`` is ``"registrant_contact"``.
This corresponds to the ``update_mask`` field
on the ``request`` instance; if ``request`` is provided, this
@@ -1004,6 +1314,9 @@ async def configure_contact_settings(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -1012,6 +1325,15 @@ async def configure_contact_settings(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -1073,20 +1395,16 @@ async def export_registration(
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> operation_async.AsyncOperation:
- r"""Exports a ``Registration`` that you no longer want to use with
- Cloud Domains. You can continue to use the domain in `Google
- Domains <https://domains.google/>`__ until it expires.
-
- If the export is successful:
+ r"""Exports a ``Registration`` resource, such that it is no longer
+ managed by Cloud Domains.
- - The resource's ``state`` becomes ``EXPORTED``, meaning that
- it is no longer managed by Cloud Domains
- - Because individual users can own domains in Google Domains,
- the calling user becomes the domain's sole owner. Permissions
- for the domain are subsequently managed in Google Domains.
- - Without further action, the domain does not renew
- automatically. The new owner can set up billing in Google
- Domains to renew the domain if needed.
+ When an active domain is successfully exported, you can continue
+ to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
Args:
request (:class:`google.cloud.domains_v1beta1.types.ExportRegistrationRequest`):
@@ -1112,6 +1430,9 @@ async def export_registration(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -1120,6 +1441,15 @@ async def export_registration(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -1177,11 +1507,26 @@ async def delete_registration(
) -> operation_async.AsyncOperation:
r"""Deletes a ``Registration`` resource.
- This method only works on resources in one of the following
- states:
+ This method works on any ``Registration`` resource using
+ `Subscription or Commitment
+ billing </domains/pricing#billing-models>`__, provided that the
+ resource was created at least 1 day in the past.
+
+ For ``Registration`` resources using `Monthly
+ billing </domains/pricing#billing-models>`__, this method works
+ if:
- ``state`` is ``EXPORTED`` with ``expire_time`` in the past
- ``state`` is ``REGISTRATION_FAILED``
+ - ``state`` is ``TRANSFER_FAILED``
+
+ When an active registration is successfully deleted, you can
+ continue to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
Args:
request (:class:`google.cloud.domains_v1beta1.types.DeleteRegistrationRequest`):
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/client.py b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/client.py
index dc9516b9becd..182e94ec5f68 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/client.py
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/client.py
@@ -588,6 +588,9 @@ def register_domain(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -596,6 +599,15 @@ def register_domain(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -646,6 +658,258 @@ def register_domain(
# Done; return the response.
return response
+ def retrieve_transfer_parameters(
+ self,
+ request: Union[domains.RetrieveTransferParametersRequest, dict] = None,
+ *,
+ location: str = None,
+ domain_name: str = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> domains.RetrieveTransferParametersResponse:
+ r"""Gets parameters needed to transfer a domain name from another
+ registrar to Cloud Domains. For domains managed by Google
+ Domains, transferring to Cloud Domains is not supported.
+
+ Use the returned values to call ``TransferDomain``.
+
+ Args:
+ request (Union[google.cloud.domains_v1beta1.types.RetrieveTransferParametersRequest, dict]):
+ The request object. Request for the
+ `RetrieveTransferParameters` method.
+ location (str):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+
+ This corresponds to the ``location`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ domain_name (str):
+ Required. The domain name. Unicode
+ domain names must be expressed in
+ Punycode format.
+
+ This corresponds to the ``domain_name`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.cloud.domains_v1beta1.types.RetrieveTransferParametersResponse:
+ Response for the RetrieveTransferParameters method.
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any([location, domain_name])
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.RetrieveTransferParametersRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.RetrieveTransferParametersRequest):
+ request = domains.RetrieveTransferParametersRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if location is not None:
+ request.location = location
+ if domain_name is not None:
+ request.domain_name = domain_name
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[
+ self._transport.retrieve_transfer_parameters
+ ]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Done; return the response.
+ return response
+
+ def transfer_domain(
+ self,
+ request: Union[domains.TransferDomainRequest, dict] = None,
+ *,
+ parent: str = None,
+ registration: domains.Registration = None,
+ yearly_price: money_pb2.Money = None,
+ authorization_code: domains.AuthorizationCode = None,
+ retry: retries.Retry = gapic_v1.method.DEFAULT,
+ timeout: float = None,
+ metadata: Sequence[Tuple[str, str]] = (),
+ ) -> operation.Operation:
+ r"""Transfers a domain name from another registrar to Cloud Domains.
+ For domains managed by Google Domains, transferring to Cloud
+ Domains is not supported.
+
+ Before calling this method, go to the domain's current registrar
+ to unlock the domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to this
+ method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``TRANSFER_PENDING``. It can take several days to complete the
+ transfer process. The registrant can often speed up this process
+ by approving the transfer through the current registrar, either
+ by clicking a link in an email from the registrar or by visiting
+ the registrar's website.
+
+ A few minutes after transfer approval, the resource transitions
+ to state ``ACTIVE``, indicating that the transfer was
+ successful. If the transfer is rejected or the request expires
+ without being approved, the resource can end up in state
+ ``TRANSFER_FAILED``. If transfer fails, you can safely delete
+ the resource and retry the transfer.
+
+ Args:
+ request (Union[google.cloud.domains_v1beta1.types.TransferDomainRequest, dict]):
+ The request object. Request for the `TransferDomain`
+ method.
+ parent (str):
+ Required. The parent resource of the ``Registration``.
+ Must be in the format ``projects/*/locations/*``.
+
+ This corresponds to the ``parent`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ registration (google.cloud.domains_v1beta1.types.Registration):
+ Required. The complete ``Registration`` resource to be
+ created.
+
+ You can leave ``registration.dns_settings`` unset to
+ import the domain's current DNS configuration from its
+ current registrar. Use this option only if you are sure
+ that the domain's current DNS service does not cease
+ upon transfer, as is often the case for DNS services
+ provided for free by the registrar.
+
+ This corresponds to the ``registration`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ yearly_price (google.type.money_pb2.Money):
+ Required. Acknowledgement of the price to transfer or
+ renew the domain for one year. Call
+ ``RetrieveTransferParameters`` to obtain the price,
+ which you must acknowledge.
+
+ This corresponds to the ``yearly_price`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ authorization_code (google.cloud.domains_v1beta1.types.AuthorizationCode):
+ The domain's transfer authorization
+ code. You can obtain this from the
+ domain's current registrar.
+
+ This corresponds to the ``authorization_code`` field
+ on the ``request`` instance; if ``request`` is provided, this
+ should not be set.
+ retry (google.api_core.retry.Retry): Designation of what errors, if any,
+ should be retried.
+ timeout (float): The timeout for this request.
+ metadata (Sequence[Tuple[str, str]]): Strings which should be
+ sent along with the request as metadata.
+
+ Returns:
+ google.api_core.operation.Operation:
+ An object representing a long-running operation.
+
+ The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
+ registrations.
+
+ There are several ways to create a new Registration
+ resource:
+
+ To create a new Registration resource, find a
+ suitable domain name by calling the SearchDomains
+ method with a query to see available domain name
+ options. After choosing a name, call
+ RetrieveRegisterParameters to ensure availability and
+ obtain information like pricing, which is needed to
+ build a call to RegisterDomain.
+
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
+ """
+ # Create or coerce a protobuf request object.
+ # Sanity check: If we got a request object, we should *not* have
+ # gotten any keyword arguments that map to the request.
+ has_flattened_params = any(
+ [parent, registration, yearly_price, authorization_code]
+ )
+ if request is not None and has_flattened_params:
+ raise ValueError(
+ "If the `request` argument is set, then none of "
+ "the individual field arguments should be set."
+ )
+
+ # Minor optimization to avoid making a copy if the user passes
+ # in a domains.TransferDomainRequest.
+ # There's no risk of modifying the input as we've already verified
+ # there are no flattened fields.
+ if not isinstance(request, domains.TransferDomainRequest):
+ request = domains.TransferDomainRequest(request)
+ # If we have keyword arguments corresponding to fields on the
+ # request, apply these.
+ if parent is not None:
+ request.parent = parent
+ if registration is not None:
+ request.registration = registration
+ if yearly_price is not None:
+ request.yearly_price = yearly_price
+ if authorization_code is not None:
+ request.authorization_code = authorization_code
+
+ # Wrap the RPC method; this adds retry and timeout information,
+ # and friendly error handling.
+ rpc = self._transport._wrapped_methods[self._transport.transfer_domain]
+
+ # Certain fields should be provided within the metadata header;
+ # add these here.
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+ )
+
+ # Send the request.
+ response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
+
+ # Wrap the response in an operation future.
+ response = operation.from_gapic(
+ response,
+ self._transport.operations_client,
+ domains.Registration,
+ metadata_type=domains.OperationMetadata,
+ )
+
+ # Done; return the response.
+ return response
+
def list_registrations(
self,
request: Union[domains.ListRegistrationsRequest, dict] = None,
@@ -759,6 +1023,9 @@ def get_registration(
The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -767,6 +1034,15 @@ def get_registration(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -837,8 +1113,8 @@ def update_registration(
update_mask (google.protobuf.field_mask_pb2.FieldMask):
Required. The field mask describing which fields to
update as a comma-separated list. For example, if only
- the labels are being updated, the ``update_mask`` would
- be ``"labels"``.
+ the labels are being updated, the ``update_mask`` is
+ ``"labels"``.
This corresponds to the ``update_mask`` field
on the ``request`` instance; if ``request`` is provided, this
@@ -856,6 +1132,9 @@ def update_registration(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -864,6 +1143,15 @@ def update_registration(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -948,7 +1236,7 @@ def configure_management_settings(
Required. The field mask describing which fields to
update as a comma-separated list. For example, if only
the transfer lock is being updated, the ``update_mask``
- would be ``"transfer_lock_state"``.
+ is ``"transfer_lock_state"``.
This corresponds to the ``update_mask`` field
on the ``request`` instance; if ``request`` is provided, this
@@ -966,6 +1254,9 @@ def configure_management_settings(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -974,6 +1265,15 @@ def configure_management_settings(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -1062,14 +1362,14 @@ def configure_dns_settings(
Required. The field mask describing which fields to
update as a comma-separated list. For example, if only
the name servers are being updated for an existing
- Custom DNS configuration, the ``update_mask`` would be
+ Custom DNS configuration, the ``update_mask`` is
``"custom_dns.name_servers"``.
When changing the DNS provider from one type to another,
pass the new provider's field name as part of the field
mask. For example, when changing from a Google Domains
DNS configuration to a Custom DNS configuration, the
- ``update_mask`` would be ``"custom_dns"``. //
+ ``update_mask`` is ``"custom_dns"``. //
This corresponds to the ``update_mask`` field
on the ``request`` instance; if ``request`` is provided, this
@@ -1087,6 +1387,9 @@ def configure_dns_settings(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -1095,6 +1398,15 @@ def configure_dns_settings(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -1182,7 +1494,7 @@ def configure_contact_settings(
Required. The field mask describing which fields to
update as a comma-separated list. For example, if only
the registrant contact is being updated, the
- ``update_mask`` would be ``"registrant_contact"``.
+ ``update_mask`` is ``"registrant_contact"``.
This corresponds to the ``update_mask`` field
on the ``request`` instance; if ``request`` is provided, this
@@ -1200,6 +1512,9 @@ def configure_contact_settings(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -1208,6 +1523,15 @@ def configure_contact_settings(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -1271,20 +1595,16 @@ def export_registration(
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> operation.Operation:
- r"""Exports a ``Registration`` that you no longer want to use with
- Cloud Domains. You can continue to use the domain in `Google
- Domains <https://domains.google/>`__ until it expires.
-
- If the export is successful:
+ r"""Exports a ``Registration`` resource, such that it is no longer
+ managed by Cloud Domains.
- - The resource's ``state`` becomes ``EXPORTED``, meaning that
- it is no longer managed by Cloud Domains
- - Because individual users can own domains in Google Domains,
- the calling user becomes the domain's sole owner. Permissions
- for the domain are subsequently managed in Google Domains.
- - Without further action, the domain does not renew
- automatically. The new owner can set up billing in Google
- Domains to renew the domain if needed.
+ When an active domain is successfully exported, you can continue
+ to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
Args:
request (Union[google.cloud.domains_v1beta1.types.ExportRegistrationRequest, dict]):
@@ -1310,6 +1630,9 @@ def export_registration(
The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name
registrations.
+ There are several ways to create a new Registration
+ resource:
+
To create a new Registration resource, find a
suitable domain name by calling the SearchDomains
method with a query to see available domain name
@@ -1318,6 +1641,15 @@ def export_registration(
obtain information like pricing, which is needed to
build a call to RegisterDomain.
+ Another way to create a new Registration is to
+ transfer an existing domain from another registrar.
+ First, go to the current registrar to unlock the
+ domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ RetrieveTransferParameters to confirm that the domain
+ is unlocked and to get values needed to build a call
+ to TransferDomain.
+
"""
# Create or coerce a protobuf request object.
# Sanity check: If we got a request object, we should *not* have
@@ -1375,11 +1707,26 @@ def delete_registration(
) -> operation.Operation:
r"""Deletes a ``Registration`` resource.
- This method only works on resources in one of the following
- states:
+ This method works on any ``Registration`` resource using
+ `Subscription or Commitment
+ billing </domains/pricing#billing-models>`__, provided that the
+ resource was created at least 1 day in the past.
+
+ For ``Registration`` resources using `Monthly
+ billing </domains/pricing#billing-models>`__, this method works
+ if:
- ``state`` is ``EXPORTED`` with ``expire_time`` in the past
- ``state`` is ``REGISTRATION_FAILED``
+ - ``state`` is ``TRANSFER_FAILED``
+
+ When an active registration is successfully deleted, you can
+ continue to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
Args:
request (Union[google.cloud.domains_v1beta1.types.DeleteRegistrationRequest, dict]):
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/base.py b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/base.py
index 561c774e505f..f95e6f98fadd 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/base.py
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/base.py
@@ -165,6 +165,14 @@ def _prep_wrapped_messages(self, client_info):
self.register_domain: gapic_v1.method.wrap_method(
self.register_domain, default_timeout=None, client_info=client_info,
),
+ self.retrieve_transfer_parameters: gapic_v1.method.wrap_method(
+ self.retrieve_transfer_parameters,
+ default_timeout=None,
+ client_info=client_info,
+ ),
+ self.transfer_domain: gapic_v1.method.wrap_method(
+ self.transfer_domain, default_timeout=None, client_info=client_info,
+ ),
self.list_registrations: gapic_v1.method.wrap_method(
self.list_registrations, default_timeout=None, client_info=client_info,
),
@@ -251,6 +259,27 @@ def register_domain(
]:
raise NotImplementedError()
+ @property
+ def retrieve_transfer_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveTransferParametersRequest],
+ Union[
+ domains.RetrieveTransferParametersResponse,
+ Awaitable[domains.RetrieveTransferParametersResponse],
+ ],
+ ]:
+ raise NotImplementedError()
+
+ @property
+ def transfer_domain(
+ self,
+ ) -> Callable[
+ [domains.TransferDomainRequest],
+ Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+ ]:
+ raise NotImplementedError()
+
@property
def list_registrations(
self,
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/grpc.py b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/grpc.py
index 2e52c37e5cdd..a7b69f1a170b 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/grpc.py
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/grpc.py
@@ -344,6 +344,88 @@ def register_domain(
)
return self._stubs["register_domain"]
+ @property
+ def retrieve_transfer_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveTransferParametersRequest],
+ domains.RetrieveTransferParametersResponse,
+ ]:
+ r"""Return a callable for the retrieve transfer parameters method over gRPC.
+
+ Gets parameters needed to transfer a domain name from another
+ registrar to Cloud Domains. For domains managed by Google
+ Domains, transferring to Cloud Domains is not supported.
+
+ Use the returned values to call ``TransferDomain``.
+
+ Returns:
+ Callable[[~.RetrieveTransferParametersRequest],
+ ~.RetrieveTransferParametersResponse]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "retrieve_transfer_parameters" not in self._stubs:
+ self._stubs["retrieve_transfer_parameters"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1beta1.Domains/RetrieveTransferParameters",
+ request_serializer=domains.RetrieveTransferParametersRequest.serialize,
+ response_deserializer=domains.RetrieveTransferParametersResponse.deserialize,
+ )
+ return self._stubs["retrieve_transfer_parameters"]
+
+ @property
+ def transfer_domain(
+ self,
+ ) -> Callable[[domains.TransferDomainRequest], operations_pb2.Operation]:
+ r"""Return a callable for the transfer domain method over gRPC.
+
+ Transfers a domain name from another registrar to Cloud Domains.
+ For domains managed by Google Domains, transferring to Cloud
+ Domains is not supported.
+
+ Before calling this method, go to the domain's current registrar
+ to unlock the domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to this
+ method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``TRANSFER_PENDING``. It can take several days to complete the
+ transfer process. The registrant can often speed up this process
+ by approving the transfer through the current registrar, either
+ by clicking a link in an email from the registrar or by visiting
+ the registrar's website.
+
+ A few minutes after transfer approval, the resource transitions
+ to state ``ACTIVE``, indicating that the transfer was
+ successful. If the transfer is rejected or the request expires
+ without being approved, the resource can end up in state
+ ``TRANSFER_FAILED``. If transfer fails, you can safely delete
+ the resource and retry the transfer.
+
+ Returns:
+ Callable[[~.TransferDomainRequest],
+ ~.Operation]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "transfer_domain" not in self._stubs:
+ self._stubs["transfer_domain"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1beta1.Domains/TransferDomain",
+ request_serializer=domains.TransferDomainRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["transfer_domain"]
+
@property
def list_registrations(
self,
@@ -521,20 +603,16 @@ def export_registration(
) -> Callable[[domains.ExportRegistrationRequest], operations_pb2.Operation]:
r"""Return a callable for the export registration method over gRPC.
- Exports a ``Registration`` that you no longer want to use with
- Cloud Domains. You can continue to use the domain in `Google
- Domains <https://domains.google/>`__ until it expires.
+ Exports a ``Registration`` resource, such that it is no longer
+ managed by Cloud Domains.
- If the export is successful:
-
- - The resource's ``state`` becomes ``EXPORTED``, meaning that
- it is no longer managed by Cloud Domains
- - Because individual users can own domains in Google Domains,
- the calling user becomes the domain's sole owner. Permissions
- for the domain are subsequently managed in Google Domains.
- - Without further action, the domain does not renew
- automatically. The new owner can set up billing in Google
- Domains to renew the domain if needed.
+ When an active domain is successfully exported, you can continue
+ to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
Returns:
Callable[[~.ExportRegistrationRequest],
@@ -562,11 +640,26 @@ def delete_registration(
Deletes a ``Registration`` resource.
- This method only works on resources in one of the following
- states:
+ This method works on any ``Registration`` resource using
+ `Subscription or Commitment
+ billing </domains/pricing#billing-models>`__, provided that the
+ resource was created at least 1 day in the past.
+
+ For ``Registration`` resources using `Monthly
+ billing </domains/pricing#billing-models>`__, this method works
+ if:
- ``state`` is ``EXPORTED`` with ``expire_time`` in the past
- ``state`` is ``REGISTRATION_FAILED``
+ - ``state`` is ``TRANSFER_FAILED``
+
+ When an active registration is successfully deleted, you can
+ continue to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
Returns:
Callable[[~.DeleteRegistrationRequest],
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/grpc_asyncio.py b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/grpc_asyncio.py
index 097612baecc1..dc5afa220c2f 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/grpc_asyncio.py
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/services/domains/transports/grpc_asyncio.py
@@ -351,6 +351,88 @@ def register_domain(
)
return self._stubs["register_domain"]
+ @property
+ def retrieve_transfer_parameters(
+ self,
+ ) -> Callable[
+ [domains.RetrieveTransferParametersRequest],
+ Awaitable[domains.RetrieveTransferParametersResponse],
+ ]:
+ r"""Return a callable for the retrieve transfer parameters method over gRPC.
+
+ Gets parameters needed to transfer a domain name from another
+ registrar to Cloud Domains. For domains managed by Google
+ Domains, transferring to Cloud Domains is not supported.
+
+ Use the returned values to call ``TransferDomain``.
+
+ Returns:
+ Callable[[~.RetrieveTransferParametersRequest],
+ Awaitable[~.RetrieveTransferParametersResponse]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "retrieve_transfer_parameters" not in self._stubs:
+ self._stubs["retrieve_transfer_parameters"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1beta1.Domains/RetrieveTransferParameters",
+ request_serializer=domains.RetrieveTransferParametersRequest.serialize,
+ response_deserializer=domains.RetrieveTransferParametersResponse.deserialize,
+ )
+ return self._stubs["retrieve_transfer_parameters"]
+
+ @property
+ def transfer_domain(
+ self,
+ ) -> Callable[[domains.TransferDomainRequest], Awaitable[operations_pb2.Operation]]:
+ r"""Return a callable for the transfer domain method over gRPC.
+
+ Transfers a domain name from another registrar to Cloud Domains.
+ For domains managed by Google Domains, transferring to Cloud
+ Domains is not supported.
+
+ Before calling this method, go to the domain's current registrar
+ to unlock the domain for transfer and retrieve the domain's
+ transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to this
+ method.
+
+ A successful call creates a ``Registration`` resource in state
+ ``TRANSFER_PENDING``. It can take several days to complete the
+ transfer process. The registrant can often speed up this process
+ by approving the transfer through the current registrar, either
+ by clicking a link in an email from the registrar or by visiting
+ the registrar's website.
+
+ A few minutes after transfer approval, the resource transitions
+ to state ``ACTIVE``, indicating that the transfer was
+ successful. If the transfer is rejected or the request expires
+ without being approved, the resource can end up in state
+ ``TRANSFER_FAILED``. If transfer fails, you can safely delete
+ the resource and retry the transfer.
+
+ Returns:
+ Callable[[~.TransferDomainRequest],
+ Awaitable[~.Operation]]:
+ A function that, when called, will call the underlying RPC
+ on the server.
+ """
+ # Generate a "stub function" on-the-fly which will actually make
+ # the request.
+ # gRPC handles serialization and deserialization, so we just need
+ # to pass in the functions for each.
+ if "transfer_domain" not in self._stubs:
+ self._stubs["transfer_domain"] = self.grpc_channel.unary_unary(
+ "/google.cloud.domains.v1beta1.Domains/TransferDomain",
+ request_serializer=domains.TransferDomainRequest.serialize,
+ response_deserializer=operations_pb2.Operation.FromString,
+ )
+ return self._stubs["transfer_domain"]
+
@property
def list_registrations(
self,
@@ -537,20 +619,16 @@ def export_registration(
]:
r"""Return a callable for the export registration method over gRPC.
- Exports a ``Registration`` that you no longer want to use with
- Cloud Domains. You can continue to use the domain in `Google
- Domains <https://domains.google/>`__ until it expires.
+ Exports a ``Registration`` resource, such that it is no longer
+ managed by Cloud Domains.
- If the export is successful:
-
- - The resource's ``state`` becomes ``EXPORTED``, meaning that
- it is no longer managed by Cloud Domains
- - Because individual users can own domains in Google Domains,
- the calling user becomes the domain's sole owner. Permissions
- for the domain are subsequently managed in Google Domains.
- - Without further action, the domain does not renew
- automatically. The new owner can set up billing in Google
- Domains to renew the domain if needed.
+ When an active domain is successfully exported, you can continue
+ to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
Returns:
Callable[[~.ExportRegistrationRequest],
@@ -580,11 +658,26 @@ def delete_registration(
Deletes a ``Registration`` resource.
- This method only works on resources in one of the following
- states:
+ This method works on any ``Registration`` resource using
+ `Subscription or Commitment
+ billing </domains/pricing#billing-models>`__, provided that the
+ resource was created at least 1 day in the past.
+
+ For ``Registration`` resources using `Monthly
+ billing </domains/pricing#billing-models>`__, this method works
+ if:
- ``state`` is ``EXPORTED`` with ``expire_time`` in the past
- ``state`` is ``REGISTRATION_FAILED``
+ - ``state`` is ``TRANSFER_FAILED``
+
+ When an active registration is successfully deleted, you can
+ continue to use the domain in `Google
+ Domains <https://domains.google/>`__ until it expires. The
+ calling user becomes the domain's sole owner in Google Domains,
+ and permissions for the domain are subsequently managed there.
+ The domain does not renew automatically unless the new owner
+ sets up billing in Google Domains.
Returns:
Callable[[~.DeleteRegistrationRequest],
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/types/__init__.py b/packages/google-cloud-domains/google/cloud/domains_v1beta1/types/__init__.py
index 73c9baa1a8a5..2ccb2c4772d2 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/types/__init__.py
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/types/__init__.py
@@ -34,8 +34,12 @@
RetrieveAuthorizationCodeRequest,
RetrieveRegisterParametersRequest,
RetrieveRegisterParametersResponse,
+ RetrieveTransferParametersRequest,
+ RetrieveTransferParametersResponse,
SearchDomainsRequest,
SearchDomainsResponse,
+ TransferDomainRequest,
+ TransferParameters,
UpdateRegistrationRequest,
ContactNotice,
ContactPrivacy,
@@ -64,8 +68,12 @@
"RetrieveAuthorizationCodeRequest",
"RetrieveRegisterParametersRequest",
"RetrieveRegisterParametersResponse",
+ "RetrieveTransferParametersRequest",
+ "RetrieveTransferParametersResponse",
"SearchDomainsRequest",
"SearchDomainsResponse",
+ "TransferDomainRequest",
+ "TransferParameters",
"UpdateRegistrationRequest",
"ContactNotice",
"ContactPrivacy",
diff --git a/packages/google-cloud-domains/google/cloud/domains_v1beta1/types/domains.py b/packages/google-cloud-domains/google/cloud/domains_v1beta1/types/domains.py
index 6f71d5eb2785..cb78f6cdd83a 100644
--- a/packages/google-cloud-domains/google/cloud/domains_v1beta1/types/domains.py
+++ b/packages/google-cloud-domains/google/cloud/domains_v1beta1/types/domains.py
@@ -37,6 +37,9 @@
"RetrieveRegisterParametersRequest",
"RetrieveRegisterParametersResponse",
"RegisterDomainRequest",
+ "RetrieveTransferParametersRequest",
+ "RetrieveTransferParametersResponse",
+ "TransferDomainRequest",
"ListRegistrationsRequest",
"ListRegistrationsResponse",
"GetRegistrationRequest",
@@ -49,6 +52,7 @@
"RetrieveAuthorizationCodeRequest",
"ResetAuthorizationCodeRequest",
"RegisterParameters",
+ "TransferParameters",
"AuthorizationCode",
"OperationMetadata",
},
@@ -94,6 +98,8 @@ class Registration(proto.Message):
r"""The ``Registration`` resource facilitates managing and configuring
domain name registrations.
+ There are several ways to create a new ``Registration`` resource:
+
To create a new ``Registration`` resource, find a suitable domain
name by calling the ``SearchDomains`` method with a query to see
available domain name options. After choosing a name, call
@@ -101,6 +107,14 @@ class Registration(proto.Message):
information like pricing, which is needed to build a call to
``RegisterDomain``.
+ Another way to create a new ``Registration`` is to transfer an
+ existing domain from another registrar. First, go to the current
+ registrar to unlock the domain for transfer and retrieve the
+ domain's transfer authorization code. Then call
+ ``RetrieveTransferParameters`` to confirm that the domain is
+ unlocked and to get values needed to build a call to
+ ``TransferDomain``.
+
Attributes:
name (str):
Output only. Name of the ``Registration`` resource, in the
@@ -145,7 +159,7 @@ class Registration(proto.Message):
require email confirmation by the ``registrant_contact``
before taking effect. This field is set only if there are
pending updates to the ``contact_settings`` that have not
- yet been confirmed. To confirm the changes, the
+ been confirmed. To confirm the changes, the
``registrant_contact`` must follow the instructions in the
email they receive.
supported_privacy (Sequence[google.cloud.domains_v1beta1.types.ContactPrivacy]):
@@ -159,6 +173,8 @@ class State(proto.Enum):
STATE_UNSPECIFIED = 0
REGISTRATION_PENDING = 1
REGISTRATION_FAILED = 2
+ TRANSFER_PENDING = 3
+ TRANSFER_FAILED = 4
ACTIVE = 6
SUSPENDED = 7
EXPORTED = 8
@@ -310,6 +326,8 @@ class Algorithm(proto.Enum):
algorithms are not supported for particular domains.
"""
ALGORITHM_UNSPECIFIED = 0
+ RSAMD5 = 1
+ DH = 2
DSA = 3
ECC = 4
RSASHA1 = 5
@@ -322,6 +340,9 @@ class Algorithm(proto.Enum):
ECDSAP384SHA384 = 14
ED25519 = 15
ED448 = 16
+ INDIRECT = 252
+ PRIVATEDNS = 253
+ PRIVATEOID = 254
class DigestType(proto.Enum):
r"""List of hash functions that may have been used to generate a
@@ -396,9 +417,9 @@ class ContactSettings(proto.Message):
number, and/or postal address can take control of the
domain.*
- *Warning: For new ``Registration``\ s, the registrant will
- receive an email confirmation that they must complete within
- 14 days to avoid domain suspension.*
+ *Warning: For new ``Registration``\ s, the registrant
+ receives an email confirmation that they must complete
+ within 15 days to avoid domain suspension.*
admin_contact (google.cloud.domains_v1beta1.types.ContactSettings.Contact):
Required. The administrative contact for the
``Registration``.
@@ -510,7 +531,7 @@ class RegisterDomainRequest(proto.Message):
acknowledgement.
contact_notices (Sequence[google.cloud.domains_v1beta1.types.ContactNotice]):
The list of contact notices that the caller acknowledges.
- The notices required here depend on the values specified in
+ The notices needed here depend on the values specified in
``registration.contact_settings``.
yearly_price (google.type.money_pb2.Money):
Required. Yearly price to register or renew
@@ -518,8 +539,8 @@ class RegisterDomainRequest(proto.Message):
can be obtained from RetrieveRegisterParameters
or SearchDomains calls.
validate_only (bool):
- When true, only validation will be performed, without
- actually registering the domain. Follows:
+ When true, only validation is performed, without actually
+ registering the domain. Follows:
https://cloud.google.com/apis/design/design_patterns#request_validation
"""
@@ -531,6 +552,80 @@ class RegisterDomainRequest(proto.Message):
validate_only = proto.Field(proto.BOOL, number=6,)
+class RetrieveTransferParametersRequest(proto.Message):
+ r"""Request for the ``RetrieveTransferParameters`` method.
+
+ Attributes:
+ domain_name (str):
+ Required. The domain name. Unicode domain
+ names must be expressed in Punycode format.
+ location (str):
+ Required. The location. Must be in the format
+ ``projects/*/locations/*``.
+ """
+
+ domain_name = proto.Field(proto.STRING, number=1,)
+ location = proto.Field(proto.STRING, number=2,)
+
+
+class RetrieveTransferParametersResponse(proto.Message):
+ r"""Response for the ``RetrieveTransferParameters`` method.
+
+ Attributes:
+ transfer_parameters (google.cloud.domains_v1beta1.types.TransferParameters):
+ Parameters to use when calling the ``TransferDomain``
+ method.
+ """
+
+ transfer_parameters = proto.Field(
+ proto.MESSAGE, number=1, message="TransferParameters",
+ )
+
+
+class TransferDomainRequest(proto.Message):
+ r"""Request for the ``TransferDomain`` method.
+
+ Attributes:
+ parent (str):
+ Required. The parent resource of the ``Registration``. Must
+ be in the format ``projects/*/locations/*``.
+ registration (google.cloud.domains_v1beta1.types.Registration):
+ Required. The complete ``Registration`` resource to be
+ created.
+
+ You can leave ``registration.dns_settings`` unset to import
+ the domain's current DNS configuration from its current
+ registrar. Use this option only if you are sure that the
+ domain's current DNS service does not cease upon transfer,
+ as is often the case for DNS services provided for free by
+ the registrar.
+ contact_notices (Sequence[google.cloud.domains_v1beta1.types.ContactNotice]):
+ The list of contact notices that you acknowledge. The
+ notices needed here depend on the values specified in
+ ``registration.contact_settings``.
+ yearly_price (google.type.money_pb2.Money):
+ Required. Acknowledgement of the price to transfer or renew
+ the domain for one year. Call ``RetrieveTransferParameters``
+ to obtain the price, which you must acknowledge.
+ authorization_code (google.cloud.domains_v1beta1.types.AuthorizationCode):
+ The domain's transfer authorization code. You
+ can obtain this from the domain's current
+ registrar.
+ validate_only (bool):
+ Validate the request without actually
+ transferring the domain.
+ """
+
+ parent = proto.Field(proto.STRING, number=1,)
+ registration = proto.Field(proto.MESSAGE, number=2, message="Registration",)
+ contact_notices = proto.RepeatedField(proto.ENUM, number=3, enum="ContactNotice",)
+ yearly_price = proto.Field(proto.MESSAGE, number=4, message=money_pb2.Money,)
+ authorization_code = proto.Field(
+ proto.MESSAGE, number=5, message="AuthorizationCode",
+ )
+ validate_only = proto.Field(proto.BOOL, number=6,)
+
+
class ListRegistrationsRequest(proto.Message):
r"""Request for the ``ListRegistrations`` method.
@@ -616,8 +711,7 @@ class UpdateRegistrationRequest(proto.Message):
update_mask (google.protobuf.field_mask_pb2.FieldMask):
Required. The field mask describing which fields to update
as a comma-separated list. For example, if only the labels
- are being updated, the ``update_mask`` would be
- ``"labels"``.
+ are being updated, the ``update_mask`` is ``"labels"``.
"""
registration = proto.Field(proto.MESSAGE, number=1, message="Registration",)
@@ -639,7 +733,7 @@ class ConfigureManagementSettingsRequest(proto.Message):
update_mask (google.protobuf.field_mask_pb2.FieldMask):
Required. The field mask describing which fields to update
as a comma-separated list. For example, if only the transfer
- lock is being updated, the ``update_mask`` would be
+ lock is being updated, the ``update_mask`` is
``"transfer_lock_state"``.
"""
@@ -666,14 +760,14 @@ class ConfigureDnsSettingsRequest(proto.Message):
Required. The field mask describing which fields to update
as a comma-separated list. For example, if only the name
servers are being updated for an existing Custom DNS
- configuration, the ``update_mask`` would be
+ configuration, the ``update_mask`` is
``"custom_dns.name_servers"``.
When changing the DNS provider from one type to another,
pass the new provider's field name as part of the field
mask. For example, when changing from a Google Domains DNS
configuration to a Custom DNS configuration, the
- ``update_mask`` would be ``"custom_dns"``. //
+ ``update_mask`` is ``"custom_dns"``. //
validate_only (bool):
Validate the request without actually
updating the DNS settings.
@@ -700,11 +794,11 @@ class ConfigureContactSettingsRequest(proto.Message):
update_mask (google.protobuf.field_mask_pb2.FieldMask):
Required. The field mask describing which fields to update
as a comma-separated list. For example, if only the
- registrant contact is being updated, the ``update_mask``
- would be ``"registrant_contact"``.
+ registrant contact is being updated, the ``update_mask`` is
+ ``"registrant_contact"``.
contact_notices (Sequence[google.cloud.domains_v1beta1.types.ContactNotice]):
The list of contact notices that the caller acknowledges.
- The notices required here depend on the values specified in
+ The notices needed here depend on the values specified in
``contact_settings``.
validate_only (bool):
Validate the request without actually
@@ -810,6 +904,43 @@ class Availability(proto.Enum):
yearly_price = proto.Field(proto.MESSAGE, number=5, message=money_pb2.Money,)
+class TransferParameters(proto.Message):
+ r"""Parameters required to transfer a domain from another
+ registrar.
+
+ Attributes:
+ domain_name (str):
+ The domain name. Unicode domain names are
+ expressed in Punycode format.
+ current_registrar (str):
+ The registrar that currently manages the
+ domain.
+ name_servers (Sequence[str]):
+ The name servers that currently store the
+ configuration of the domain.
+ transfer_lock_state (google.cloud.domains_v1beta1.types.TransferLockState):
+ Indicates whether the domain is protected by a transfer
+ lock. For a transfer to succeed, this must show
+ ``UNLOCKED``. To unlock a domain, go to its current
+ registrar.
+ supported_privacy (Sequence[google.cloud.domains_v1beta1.types.ContactPrivacy]):
+ Contact privacy options that the domain
+ supports.
+ yearly_price (google.type.money_pb2.Money):
+ Price to transfer or renew the domain for one
+ year.
+ """
+
+ domain_name = proto.Field(proto.STRING, number=1,)
+ current_registrar = proto.Field(proto.STRING, number=2,)
+ name_servers = proto.RepeatedField(proto.STRING, number=3,)
+ transfer_lock_state = proto.Field(proto.ENUM, number=4, enum="TransferLockState",)
+ supported_privacy = proto.RepeatedField(
+ proto.ENUM, number=5, enum="ContactPrivacy",
+ )
+ yearly_price = proto.Field(proto.MESSAGE, number=6, message=money_pb2.Money,)
+
+
class AuthorizationCode(proto.Message):
r"""Defines an authorization code.
diff --git a/packages/google-cloud-domains/scripts/fixup_domains_v1_keywords.py b/packages/google-cloud-domains/scripts/fixup_domains_v1_keywords.py
new file mode 100644
index 000000000000..beb9285ead1d
--- /dev/null
+++ b/packages/google-cloud-domains/scripts/fixup_domains_v1_keywords.py
@@ -0,0 +1,190 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import argparse
+import os
+import libcst as cst
+import pathlib
+import sys
+from typing import (Any, Callable, Dict, List, Sequence, Tuple)
+
+
+def partition(
+ predicate: Callable[[Any], bool],
+ iterator: Sequence[Any]
+) -> Tuple[List[Any], List[Any]]:
+ """A stable, out-of-place partition."""
+ results = ([], [])
+
+ for i in iterator:
+ results[int(predicate(i))].append(i)
+
+ # Returns trueList, falseList
+ return results[1], results[0]
+
+
+class domainsCallTransformer(cst.CSTTransformer):
+ CTRL_PARAMS: Tuple[str] = ('retry', 'timeout', 'metadata')
+ METHOD_TO_PARAMS: Dict[str, Tuple[str]] = {
+ 'configure_contact_settings': ('registration', 'update_mask', 'contact_settings', 'contact_notices', 'validate_only', ),
+ 'configure_dns_settings': ('registration', 'update_mask', 'dns_settings', 'validate_only', ),
+ 'configure_management_settings': ('registration', 'update_mask', 'management_settings', ),
+ 'delete_registration': ('name', ),
+ 'export_registration': ('name', ),
+ 'get_registration': ('name', ),
+ 'list_registrations': ('parent', 'page_size', 'page_token', 'filter', ),
+ 'register_domain': ('parent', 'registration', 'yearly_price', 'domain_notices', 'contact_notices', 'validate_only', ),
+ 'reset_authorization_code': ('registration', ),
+ 'retrieve_authorization_code': ('registration', ),
+ 'retrieve_register_parameters': ('domain_name', 'location', ),
+ 'retrieve_transfer_parameters': ('domain_name', 'location', ),
+ 'search_domains': ('query', 'location', ),
+ 'transfer_domain': ('parent', 'registration', 'yearly_price', 'contact_notices', 'authorization_code', 'validate_only', ),
+ 'update_registration': ('update_mask', 'registration', ),
+ }
+
+ def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.CSTNode:
+ try:
+ key = original.func.attr.value
+ kword_params = self.METHOD_TO_PARAMS[key]
+ except (AttributeError, KeyError):
+ # Either not a method from the API or too convoluted to be sure.
+ return updated
+
+ # If the existing code is valid, keyword args come after positional args.
+ # Therefore, all positional args must map to the first parameters.
+ args, kwargs = partition(lambda a: not bool(a.keyword), updated.args)
+ if any(k.keyword.value == "request" for k in kwargs):
+ # We've already fixed this file, don't fix it again.
+ return updated
+
+ kwargs, ctrl_kwargs = partition(
+ lambda a: a.keyword.value not in self.CTRL_PARAMS,
+ kwargs
+ )
+
+ args, ctrl_args = args[:len(kword_params)], args[len(kword_params):]
+ ctrl_kwargs.extend(cst.Arg(value=a.value, keyword=cst.Name(value=ctrl))
+ for a, ctrl in zip(ctrl_args, self.CTRL_PARAMS))
+
+ request_arg = cst.Arg(
+ value=cst.Dict([
+ cst.DictElement(
+ cst.SimpleString("'{}'".format(name)),
+cst.Element(value=arg.value)
+ )
+ # Note: the args + kwargs looks silly, but keep in mind that
+ # the control parameters had to be stripped out, and that
+ # those could have been passed positionally or by keyword.
+ for name, arg in zip(kword_params, args + kwargs)]),
+ keyword=cst.Name("request")
+ )
+
+ return updated.with_changes(
+ args=[request_arg] + ctrl_kwargs
+ )
+
+
+def fix_files(
+ in_dir: pathlib.Path,
+ out_dir: pathlib.Path,
+ *,
+ transformer=domainsCallTransformer(),
+):
+ """Duplicate the input dir to the output dir, fixing file method calls.
+
+ Preconditions:
+ * in_dir is a real directory
+ * out_dir is a real, empty directory
+ """
+ pyfile_gen = (
+ pathlib.Path(os.path.join(root, f))
+ for root, _, files in os.walk(in_dir)
+ for f in files if os.path.splitext(f)[1] == ".py"
+ )
+
+ for fpath in pyfile_gen:
+ with open(fpath, 'r') as f:
+ src = f.read()
+
+ # Parse the code and insert method call fixes.
+ tree = cst.parse_module(src)
+ updated = tree.visit(transformer)
+
+ # Create the path and directory structure for the new file.
+ updated_path = out_dir.joinpath(fpath.relative_to(in_dir))
+ updated_path.parent.mkdir(parents=True, exist_ok=True)
+
+ # Generate the updated source file at the corresponding path.
+ with open(updated_path, 'w') as f:
+ f.write(updated.code)
+
+
+if __name__ == '__main__':
+ parser = argparse.ArgumentParser(
+ description="""Fix up source that uses the domains client library.
+
+The existing sources are NOT overwritten but are copied to output_dir with changes made.
+
+Note: This tool operates at a best-effort level at converting positional
+ parameters in client method calls to keyword based parameters.
+ Cases where it WILL FAIL include
+ A) * or ** expansion in a method call.
+ B) Calls via function or method alias (includes free function calls)
+ C) Indirect or dispatched calls (e.g. the method is looked up dynamically)
+
+ These all constitute false negatives. The tool will also detect false
+ positives when an API method shares a name with another method.
+""")
+ parser.add_argument(
+ '-d',
+ '--input-directory',
+ required=True,
+ dest='input_dir',
+ help='the input directory to walk for python files to fix up',
+ )
+ parser.add_argument(
+ '-o',
+ '--output-directory',
+ required=True,
+ dest='output_dir',
+ help='the directory to output files fixed via un-flattening',
+ )
+ args = parser.parse_args()
+ input_dir = pathlib.Path(args.input_dir)
+ output_dir = pathlib.Path(args.output_dir)
+ if not input_dir.is_dir():
+ print(
+ f"input directory '{input_dir}' does not exist or is not a directory",
+ file=sys.stderr,
+ )
+ sys.exit(-1)
+
+ if not output_dir.is_dir():
+ print(
+ f"output directory '{output_dir}' does not exist or is not a directory",
+ file=sys.stderr,
+ )
+ sys.exit(-1)
+
+ if os.listdir(output_dir):
+ print(
+ f"output directory '{output_dir}' is not empty",
+ file=sys.stderr,
+ )
+ sys.exit(-1)
+
+ fix_files(input_dir, output_dir)
diff --git a/packages/google-cloud-domains/scripts/fixup_domains_v1beta1_keywords.py b/packages/google-cloud-domains/scripts/fixup_domains_v1beta1_keywords.py
index 8f86caf5be6d..beb9285ead1d 100644
--- a/packages/google-cloud-domains/scripts/fixup_domains_v1beta1_keywords.py
+++ b/packages/google-cloud-domains/scripts/fixup_domains_v1beta1_keywords.py
@@ -50,7 +50,9 @@ class domainsCallTransformer(cst.CSTTransformer):
'reset_authorization_code': ('registration', ),
'retrieve_authorization_code': ('registration', ),
'retrieve_register_parameters': ('domain_name', 'location', ),
+ 'retrieve_transfer_parameters': ('domain_name', 'location', ),
'search_domains': ('query', 'location', ),
+ 'transfer_domain': ('parent', 'registration', 'yearly_price', 'contact_notices', 'authorization_code', 'validate_only', ),
'update_registration': ('update_mask', 'registration', ),
}
diff --git a/packages/google-cloud-domains/tests/unit/gapic/domains_v1/__init__.py b/packages/google-cloud-domains/tests/unit/gapic/domains_v1/__init__.py
new file mode 100644
index 000000000000..4de65971c238
--- /dev/null
+++ b/packages/google-cloud-domains/tests/unit/gapic/domains_v1/__init__.py
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 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.
+#
diff --git a/packages/google-cloud-domains/tests/unit/gapic/domains_v1/test_domains.py b/packages/google-cloud-domains/tests/unit/gapic/domains_v1/test_domains.py
new file mode 100644
index 000000000000..02c853f32037
--- /dev/null
+++ b/packages/google-cloud-domains/tests/unit/gapic/domains_v1/test_domains.py
@@ -0,0 +1,4603 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import os
+import mock
+import packaging.version
+
+import grpc
+from grpc.experimental import aio
+import math
+import pytest
+from proto.marshal.rules.dates import DurationRule, TimestampRule
+
+
+from google.api_core import client_options
+from google.api_core import exceptions as core_exceptions
+from google.api_core import future
+from google.api_core import gapic_v1
+from google.api_core import grpc_helpers
+from google.api_core import grpc_helpers_async
+from google.api_core import operation_async # type: ignore
+from google.api_core import operations_v1
+from google.api_core import path_template
+from google.auth import credentials as ga_credentials
+from google.auth.exceptions import MutualTLSChannelError
+from google.cloud.domains_v1.services.domains import DomainsAsyncClient
+from google.cloud.domains_v1.services.domains import DomainsClient
+from google.cloud.domains_v1.services.domains import pagers
+from google.cloud.domains_v1.services.domains import transports
+from google.cloud.domains_v1.services.domains.transports.base import (
+ _GOOGLE_AUTH_VERSION,
+)
+from google.cloud.domains_v1.types import domains
+from google.longrunning import operations_pb2
+from google.oauth2 import service_account
+from google.protobuf import field_mask_pb2 # type: ignore
+from google.protobuf import timestamp_pb2 # type: ignore
+from google.type import money_pb2 # type: ignore
+from google.type import postal_address_pb2 # type: ignore
+import google.auth
+
+
+# TODO(busunkim): Once google-auth >= 1.25.0 is required transitively
+# through google-api-core:
+# - Delete the auth "less than" test cases
+# - Delete these pytest markers (Make the "greater than or equal to" tests the default).
+requires_google_auth_lt_1_25_0 = pytest.mark.skipif(
+ packaging.version.parse(_GOOGLE_AUTH_VERSION) >= packaging.version.parse("1.25.0"),
+ reason="This test requires google-auth < 1.25.0",
+)
+requires_google_auth_gte_1_25_0 = pytest.mark.skipif(
+ packaging.version.parse(_GOOGLE_AUTH_VERSION) < packaging.version.parse("1.25.0"),
+ reason="This test requires google-auth >= 1.25.0",
+)
+
+
+def client_cert_source_callback():
+ return b"cert bytes", b"key bytes"
+
+
+# If default endpoint is localhost, then default mtls endpoint will be the same.
+# This method modifies the default endpoint so the client can produce a different
+# mtls endpoint for endpoint testing purposes.
+def modify_default_endpoint(client):
+ return (
+ "foo.googleapis.com"
+ if ("localhost" in client.DEFAULT_ENDPOINT)
+ else client.DEFAULT_ENDPOINT
+ )
+
+
+def test__get_default_mtls_endpoint():
+ api_endpoint = "example.googleapis.com"
+ api_mtls_endpoint = "example.mtls.googleapis.com"
+ sandbox_endpoint = "example.sandbox.googleapis.com"
+ sandbox_mtls_endpoint = "example.mtls.sandbox.googleapis.com"
+ non_googleapi = "api.example.com"
+
+ assert DomainsClient._get_default_mtls_endpoint(None) is None
+ assert DomainsClient._get_default_mtls_endpoint(api_endpoint) == api_mtls_endpoint
+ assert (
+ DomainsClient._get_default_mtls_endpoint(api_mtls_endpoint) == api_mtls_endpoint
+ )
+ assert (
+ DomainsClient._get_default_mtls_endpoint(sandbox_endpoint)
+ == sandbox_mtls_endpoint
+ )
+ assert (
+ DomainsClient._get_default_mtls_endpoint(sandbox_mtls_endpoint)
+ == sandbox_mtls_endpoint
+ )
+ assert DomainsClient._get_default_mtls_endpoint(non_googleapi) == non_googleapi
+
+
+@pytest.mark.parametrize("client_class", [DomainsClient, DomainsAsyncClient,])
+def test_domains_client_from_service_account_info(client_class):
+ creds = ga_credentials.AnonymousCredentials()
+ with mock.patch.object(
+ service_account.Credentials, "from_service_account_info"
+ ) as factory:
+ factory.return_value = creds
+ info = {"valid": True}
+ client = client_class.from_service_account_info(info)
+ assert client.transport._credentials == creds
+ assert isinstance(client, client_class)
+
+ assert client.transport._host == "domains.googleapis.com:443"
+
+
+@pytest.mark.parametrize(
+ "transport_class,transport_name",
+ [
+ (transports.DomainsGrpcTransport, "grpc"),
+ (transports.DomainsGrpcAsyncIOTransport, "grpc_asyncio"),
+ ],
+)
+def test_domains_client_service_account_always_use_jwt(transport_class, transport_name):
+ with mock.patch.object(
+ service_account.Credentials, "with_always_use_jwt_access", create=True
+ ) as use_jwt:
+ creds = service_account.Credentials(None, None, None)
+ transport = transport_class(credentials=creds, always_use_jwt_access=True)
+ use_jwt.assert_called_once_with(True)
+
+ with mock.patch.object(
+ service_account.Credentials, "with_always_use_jwt_access", create=True
+ ) as use_jwt:
+ creds = service_account.Credentials(None, None, None)
+ transport = transport_class(credentials=creds, always_use_jwt_access=False)
+ use_jwt.assert_not_called()
+
+
+@pytest.mark.parametrize("client_class", [DomainsClient, DomainsAsyncClient,])
+def test_domains_client_from_service_account_file(client_class):
+ creds = ga_credentials.AnonymousCredentials()
+ with mock.patch.object(
+ service_account.Credentials, "from_service_account_file"
+ ) as factory:
+ factory.return_value = creds
+ client = client_class.from_service_account_file("dummy/file/path.json")
+ assert client.transport._credentials == creds
+ assert isinstance(client, client_class)
+
+ client = client_class.from_service_account_json("dummy/file/path.json")
+ assert client.transport._credentials == creds
+ assert isinstance(client, client_class)
+
+ assert client.transport._host == "domains.googleapis.com:443"
+
+
+def test_domains_client_get_transport_class():
+ transport = DomainsClient.get_transport_class()
+ available_transports = [
+ transports.DomainsGrpcTransport,
+ ]
+ assert transport in available_transports
+
+ transport = DomainsClient.get_transport_class("grpc")
+ assert transport == transports.DomainsGrpcTransport
+
+
+@pytest.mark.parametrize(
+ "client_class,transport_class,transport_name",
+ [
+ (DomainsClient, transports.DomainsGrpcTransport, "grpc"),
+ (DomainsAsyncClient, transports.DomainsGrpcAsyncIOTransport, "grpc_asyncio"),
+ ],
+)
+@mock.patch.object(
+ DomainsClient, "DEFAULT_ENDPOINT", modify_default_endpoint(DomainsClient)
+)
+@mock.patch.object(
+ DomainsAsyncClient, "DEFAULT_ENDPOINT", modify_default_endpoint(DomainsAsyncClient)
+)
+def test_domains_client_client_options(client_class, transport_class, transport_name):
+ # Check that if channel is provided we won't create a new one.
+ with mock.patch.object(DomainsClient, "get_transport_class") as gtc:
+ transport = transport_class(credentials=ga_credentials.AnonymousCredentials())
+ client = client_class(transport=transport)
+ gtc.assert_not_called()
+
+ # Check that if channel is provided via str we will create a new one.
+ with mock.patch.object(DomainsClient, "get_transport_class") as gtc:
+ client = client_class(transport=transport_name)
+ gtc.assert_called()
+
+ # Check the case api_endpoint is provided.
+ options = client_options.ClientOptions(api_endpoint="squid.clam.whelk")
+ with mock.patch.object(transport_class, "__init__") as patched:
+ patched.return_value = None
+ client = client_class(client_options=options)
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host="squid.clam.whelk",
+ scopes=None,
+ client_cert_source_for_mtls=None,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+ # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is
+ # "never".
+ with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}):
+ with mock.patch.object(transport_class, "__init__") as patched:
+ patched.return_value = None
+ client = client_class()
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host=client.DEFAULT_ENDPOINT,
+ scopes=None,
+ client_cert_source_for_mtls=None,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+ # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is
+ # "always".
+ with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}):
+ with mock.patch.object(transport_class, "__init__") as patched:
+ patched.return_value = None
+ client = client_class()
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host=client.DEFAULT_MTLS_ENDPOINT,
+ scopes=None,
+ client_cert_source_for_mtls=None,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+ # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT has
+ # unsupported value.
+ with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}):
+ with pytest.raises(MutualTLSChannelError):
+ client = client_class()
+
+ # Check the case GOOGLE_API_USE_CLIENT_CERTIFICATE has unsupported value.
+ with mock.patch.dict(
+ os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"}
+ ):
+ with pytest.raises(ValueError):
+ client = client_class()
+
+ # Check the case quota_project_id is provided
+ options = client_options.ClientOptions(quota_project_id="octopus")
+ with mock.patch.object(transport_class, "__init__") as patched:
+ patched.return_value = None
+ client = client_class(client_options=options)
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host=client.DEFAULT_ENDPOINT,
+ scopes=None,
+ client_cert_source_for_mtls=None,
+ quota_project_id="octopus",
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+
+@pytest.mark.parametrize(
+ "client_class,transport_class,transport_name,use_client_cert_env",
+ [
+ (DomainsClient, transports.DomainsGrpcTransport, "grpc", "true"),
+ (
+ DomainsAsyncClient,
+ transports.DomainsGrpcAsyncIOTransport,
+ "grpc_asyncio",
+ "true",
+ ),
+ (DomainsClient, transports.DomainsGrpcTransport, "grpc", "false"),
+ (
+ DomainsAsyncClient,
+ transports.DomainsGrpcAsyncIOTransport,
+ "grpc_asyncio",
+ "false",
+ ),
+ ],
+)
+@mock.patch.object(
+ DomainsClient, "DEFAULT_ENDPOINT", modify_default_endpoint(DomainsClient)
+)
+@mock.patch.object(
+ DomainsAsyncClient, "DEFAULT_ENDPOINT", modify_default_endpoint(DomainsAsyncClient)
+)
+@mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "auto"})
+def test_domains_client_mtls_env_auto(
+ client_class, transport_class, transport_name, use_client_cert_env
+):
+ # This tests the endpoint autoswitch behavior. Endpoint is autoswitched to the default
+ # mtls endpoint, if GOOGLE_API_USE_CLIENT_CERTIFICATE is "true" and client cert exists.
+
+ # Check the case client_cert_source is provided. Whether client cert is used depends on
+ # GOOGLE_API_USE_CLIENT_CERTIFICATE value.
+ with mock.patch.dict(
+ os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}
+ ):
+ options = client_options.ClientOptions(
+ client_cert_source=client_cert_source_callback
+ )
+ with mock.patch.object(transport_class, "__init__") as patched:
+ patched.return_value = None
+ client = client_class(client_options=options)
+
+ if use_client_cert_env == "false":
+ expected_client_cert_source = None
+ expected_host = client.DEFAULT_ENDPOINT
+ else:
+ expected_client_cert_source = client_cert_source_callback
+ expected_host = client.DEFAULT_MTLS_ENDPOINT
+
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host=expected_host,
+ scopes=None,
+ client_cert_source_for_mtls=expected_client_cert_source,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+ # Check the case ADC client cert is provided. Whether client cert is used depends on
+ # GOOGLE_API_USE_CLIENT_CERTIFICATE value.
+ with mock.patch.dict(
+ os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}
+ ):
+ with mock.patch.object(transport_class, "__init__") as patched:
+ with mock.patch(
+ "google.auth.transport.mtls.has_default_client_cert_source",
+ return_value=True,
+ ):
+ with mock.patch(
+ "google.auth.transport.mtls.default_client_cert_source",
+ return_value=client_cert_source_callback,
+ ):
+ if use_client_cert_env == "false":
+ expected_host = client.DEFAULT_ENDPOINT
+ expected_client_cert_source = None
+ else:
+ expected_host = client.DEFAULT_MTLS_ENDPOINT
+ expected_client_cert_source = client_cert_source_callback
+
+ patched.return_value = None
+ client = client_class()
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host=expected_host,
+ scopes=None,
+ client_cert_source_for_mtls=expected_client_cert_source,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+ # Check the case client_cert_source and ADC client cert are not provided.
+ with mock.patch.dict(
+ os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}
+ ):
+ with mock.patch.object(transport_class, "__init__") as patched:
+ with mock.patch(
+ "google.auth.transport.mtls.has_default_client_cert_source",
+ return_value=False,
+ ):
+ patched.return_value = None
+ client = client_class()
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host=client.DEFAULT_ENDPOINT,
+ scopes=None,
+ client_cert_source_for_mtls=None,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+
+@pytest.mark.parametrize(
+ "client_class,transport_class,transport_name",
+ [
+ (DomainsClient, transports.DomainsGrpcTransport, "grpc"),
+ (DomainsAsyncClient, transports.DomainsGrpcAsyncIOTransport, "grpc_asyncio"),
+ ],
+)
+def test_domains_client_client_options_scopes(
+ client_class, transport_class, transport_name
+):
+ # Check the case scopes are provided.
+ options = client_options.ClientOptions(scopes=["1", "2"],)
+ with mock.patch.object(transport_class, "__init__") as patched:
+ patched.return_value = None
+ client = client_class(client_options=options)
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host=client.DEFAULT_ENDPOINT,
+ scopes=["1", "2"],
+ client_cert_source_for_mtls=None,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+
+@pytest.mark.parametrize(
+ "client_class,transport_class,transport_name",
+ [
+ (DomainsClient, transports.DomainsGrpcTransport, "grpc"),
+ (DomainsAsyncClient, transports.DomainsGrpcAsyncIOTransport, "grpc_asyncio"),
+ ],
+)
+def test_domains_client_client_options_credentials_file(
+ client_class, transport_class, transport_name
+):
+ # Check the case credentials file is provided.
+ options = client_options.ClientOptions(credentials_file="credentials.json")
+ with mock.patch.object(transport_class, "__init__") as patched:
+ patched.return_value = None
+ client = client_class(client_options=options)
+ patched.assert_called_once_with(
+ credentials=None,
+ credentials_file="credentials.json",
+ host=client.DEFAULT_ENDPOINT,
+ scopes=None,
+ client_cert_source_for_mtls=None,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+
+def test_domains_client_client_options_from_dict():
+ with mock.patch(
+ "google.cloud.domains_v1.services.domains.transports.DomainsGrpcTransport.__init__"
+ ) as grpc_transport:
+ grpc_transport.return_value = None
+ client = DomainsClient(client_options={"api_endpoint": "squid.clam.whelk"})
+ grpc_transport.assert_called_once_with(
+ credentials=None,
+ credentials_file=None,
+ host="squid.clam.whelk",
+ scopes=None,
+ client_cert_source_for_mtls=None,
+ quota_project_id=None,
+ client_info=transports.base.DEFAULT_CLIENT_INFO,
+ always_use_jwt_access=True,
+ )
+
+
+def test_search_domains(
+ transport: str = "grpc", request_type=domains.SearchDomainsRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.search_domains), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.SearchDomainsResponse()
+ response = client.search_domains(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.SearchDomainsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.SearchDomainsResponse)
+
+
+def test_search_domains_from_dict():
+ test_search_domains(request_type=dict)
+
+
+def test_search_domains_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.search_domains), "__call__") as call:
+ client.search_domains()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.SearchDomainsRequest()
+
+
+@pytest.mark.asyncio
+async def test_search_domains_async(
+ transport: str = "grpc_asyncio", request_type=domains.SearchDomainsRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.search_domains), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.SearchDomainsResponse()
+ )
+ response = await client.search_domains(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.SearchDomainsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.SearchDomainsResponse)
+
+
+@pytest.mark.asyncio
+async def test_search_domains_async_from_dict():
+ await test_search_domains_async(request_type=dict)
+
+
+def test_search_domains_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.SearchDomainsRequest()
+
+ request.location = "location/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.search_domains), "__call__") as call:
+ call.return_value = domains.SearchDomainsResponse()
+ client.search_domains(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "location=location/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_search_domains_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.SearchDomainsRequest()
+
+ request.location = "location/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.search_domains), "__call__") as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.SearchDomainsResponse()
+ )
+ await client.search_domains(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "location=location/value",) in kw["metadata"]
+
+
+def test_search_domains_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.search_domains), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.SearchDomainsResponse()
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.search_domains(
+ location="location_value", query="query_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].location == "location_value"
+ assert args[0].query == "query_value"
+
+
+def test_search_domains_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.search_domains(
+ domains.SearchDomainsRequest(),
+ location="location_value",
+ query="query_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_search_domains_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.search_domains), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.SearchDomainsResponse()
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.SearchDomainsResponse()
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.search_domains(
+ location="location_value", query="query_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].location == "location_value"
+ assert args[0].query == "query_value"
+
+
+@pytest.mark.asyncio
+async def test_search_domains_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.search_domains(
+ domains.SearchDomainsRequest(),
+ location="location_value",
+ query="query_value",
+ )
+
+
+def test_retrieve_register_parameters(
+ transport: str = "grpc", request_type=domains.RetrieveRegisterParametersRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_register_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveRegisterParametersResponse()
+ response = client.retrieve_register_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveRegisterParametersRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.RetrieveRegisterParametersResponse)
+
+
+def test_retrieve_register_parameters_from_dict():
+ test_retrieve_register_parameters(request_type=dict)
+
+
+def test_retrieve_register_parameters_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_register_parameters), "__call__"
+ ) as call:
+ client.retrieve_register_parameters()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveRegisterParametersRequest()
+
+
+@pytest.mark.asyncio
+async def test_retrieve_register_parameters_async(
+ transport: str = "grpc_asyncio",
+ request_type=domains.RetrieveRegisterParametersRequest,
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_register_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveRegisterParametersResponse()
+ )
+ response = await client.retrieve_register_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveRegisterParametersRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.RetrieveRegisterParametersResponse)
+
+
+@pytest.mark.asyncio
+async def test_retrieve_register_parameters_async_from_dict():
+ await test_retrieve_register_parameters_async(request_type=dict)
+
+
+def test_retrieve_register_parameters_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RetrieveRegisterParametersRequest()
+
+ request.location = "location/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_register_parameters), "__call__"
+ ) as call:
+ call.return_value = domains.RetrieveRegisterParametersResponse()
+ client.retrieve_register_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "location=location/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_retrieve_register_parameters_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RetrieveRegisterParametersRequest()
+
+ request.location = "location/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_register_parameters), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveRegisterParametersResponse()
+ )
+ await client.retrieve_register_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "location=location/value",) in kw["metadata"]
+
+
+def test_retrieve_register_parameters_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_register_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveRegisterParametersResponse()
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.retrieve_register_parameters(
+ location="location_value", domain_name="domain_name_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].location == "location_value"
+ assert args[0].domain_name == "domain_name_value"
+
+
+def test_retrieve_register_parameters_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.retrieve_register_parameters(
+ domains.RetrieveRegisterParametersRequest(),
+ location="location_value",
+ domain_name="domain_name_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_retrieve_register_parameters_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_register_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveRegisterParametersResponse()
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveRegisterParametersResponse()
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.retrieve_register_parameters(
+ location="location_value", domain_name="domain_name_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].location == "location_value"
+ assert args[0].domain_name == "domain_name_value"
+
+
+@pytest.mark.asyncio
+async def test_retrieve_register_parameters_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.retrieve_register_parameters(
+ domains.RetrieveRegisterParametersRequest(),
+ location="location_value",
+ domain_name="domain_name_value",
+ )
+
+
+def test_register_domain(
+ transport: str = "grpc", request_type=domains.RegisterDomainRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.register_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.register_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RegisterDomainRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_register_domain_from_dict():
+ test_register_domain(request_type=dict)
+
+
+def test_register_domain_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.register_domain), "__call__") as call:
+ client.register_domain()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RegisterDomainRequest()
+
+
+@pytest.mark.asyncio
+async def test_register_domain_async(
+ transport: str = "grpc_asyncio", request_type=domains.RegisterDomainRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.register_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.register_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RegisterDomainRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_register_domain_async_from_dict():
+ await test_register_domain_async(request_type=dict)
+
+
+def test_register_domain_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RegisterDomainRequest()
+
+ request.parent = "parent/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.register_domain), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.register_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_register_domain_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RegisterDomainRequest()
+
+ request.parent = "parent/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.register_domain), "__call__") as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.register_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"]
+
+
+def test_register_domain_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.register_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.register_domain(
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].parent == "parent_value"
+ assert args[0].registration == domains.Registration(name="name_value")
+ assert args[0].yearly_price == money_pb2.Money(
+ currency_code="currency_code_value"
+ )
+
+
+def test_register_domain_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.register_domain(
+ domains.RegisterDomainRequest(),
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ )
+
+
+@pytest.mark.asyncio
+async def test_register_domain_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.register_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.register_domain(
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].parent == "parent_value"
+ assert args[0].registration == domains.Registration(name="name_value")
+ assert args[0].yearly_price == money_pb2.Money(
+ currency_code="currency_code_value"
+ )
+
+
+@pytest.mark.asyncio
+async def test_register_domain_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.register_domain(
+ domains.RegisterDomainRequest(),
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ )
+
+
+def test_retrieve_transfer_parameters(
+ transport: str = "grpc", request_type=domains.RetrieveTransferParametersRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveTransferParametersResponse()
+ response = client.retrieve_transfer_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveTransferParametersRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.RetrieveTransferParametersResponse)
+
+
+def test_retrieve_transfer_parameters_from_dict():
+ test_retrieve_transfer_parameters(request_type=dict)
+
+
+def test_retrieve_transfer_parameters_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ client.retrieve_transfer_parameters()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveTransferParametersRequest()
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_async(
+ transport: str = "grpc_asyncio",
+ request_type=domains.RetrieveTransferParametersRequest,
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveTransferParametersResponse()
+ )
+ response = await client.retrieve_transfer_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveTransferParametersRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.RetrieveTransferParametersResponse)
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_async_from_dict():
+ await test_retrieve_transfer_parameters_async(request_type=dict)
+
+
+def test_retrieve_transfer_parameters_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RetrieveTransferParametersRequest()
+
+ request.location = "location/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ call.return_value = domains.RetrieveTransferParametersResponse()
+ client.retrieve_transfer_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "location=location/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RetrieveTransferParametersRequest()
+
+ request.location = "location/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveTransferParametersResponse()
+ )
+ await client.retrieve_transfer_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "location=location/value",) in kw["metadata"]
+
+
+def test_retrieve_transfer_parameters_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveTransferParametersResponse()
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.retrieve_transfer_parameters(
+ location="location_value", domain_name="domain_name_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].location == "location_value"
+ assert args[0].domain_name == "domain_name_value"
+
+
+def test_retrieve_transfer_parameters_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.retrieve_transfer_parameters(
+ domains.RetrieveTransferParametersRequest(),
+ location="location_value",
+ domain_name="domain_name_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveTransferParametersResponse()
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveTransferParametersResponse()
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.retrieve_transfer_parameters(
+ location="location_value", domain_name="domain_name_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].location == "location_value"
+ assert args[0].domain_name == "domain_name_value"
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.retrieve_transfer_parameters(
+ domains.RetrieveTransferParametersRequest(),
+ location="location_value",
+ domain_name="domain_name_value",
+ )
+
+
+def test_transfer_domain(
+ transport: str = "grpc", request_type=domains.TransferDomainRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.transfer_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.TransferDomainRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_transfer_domain_from_dict():
+ test_transfer_domain(request_type=dict)
+
+
+def test_transfer_domain_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ client.transfer_domain()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.TransferDomainRequest()
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_async(
+ transport: str = "grpc_asyncio", request_type=domains.TransferDomainRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.transfer_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.TransferDomainRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_async_from_dict():
+ await test_transfer_domain_async(request_type=dict)
+
+
+def test_transfer_domain_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.TransferDomainRequest()
+
+ request.parent = "parent/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.transfer_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.TransferDomainRequest()
+
+ request.parent = "parent/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.transfer_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"]
+
+
+def test_transfer_domain_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.transfer_domain(
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ authorization_code=domains.AuthorizationCode(code="code_value"),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].parent == "parent_value"
+ assert args[0].registration == domains.Registration(name="name_value")
+ assert args[0].yearly_price == money_pb2.Money(
+ currency_code="currency_code_value"
+ )
+ assert args[0].authorization_code == domains.AuthorizationCode(
+ code="code_value"
+ )
+
+
+def test_transfer_domain_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.transfer_domain(
+ domains.TransferDomainRequest(),
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ authorization_code=domains.AuthorizationCode(code="code_value"),
+ )
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.transfer_domain(
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ authorization_code=domains.AuthorizationCode(code="code_value"),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].parent == "parent_value"
+ assert args[0].registration == domains.Registration(name="name_value")
+ assert args[0].yearly_price == money_pb2.Money(
+ currency_code="currency_code_value"
+ )
+ assert args[0].authorization_code == domains.AuthorizationCode(
+ code="code_value"
+ )
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.transfer_domain(
+ domains.TransferDomainRequest(),
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ authorization_code=domains.AuthorizationCode(code="code_value"),
+ )
+
+
+def test_list_registrations(
+ transport: str = "grpc", request_type=domains.ListRegistrationsRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.ListRegistrationsResponse(
+ next_page_token="next_page_token_value",
+ )
+ response = client.list_registrations(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ListRegistrationsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, pagers.ListRegistrationsPager)
+ assert response.next_page_token == "next_page_token_value"
+
+
+def test_list_registrations_from_dict():
+ test_list_registrations(request_type=dict)
+
+
+def test_list_registrations_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ client.list_registrations()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ListRegistrationsRequest()
+
+
+@pytest.mark.asyncio
+async def test_list_registrations_async(
+ transport: str = "grpc_asyncio", request_type=domains.ListRegistrationsRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.ListRegistrationsResponse(next_page_token="next_page_token_value",)
+ )
+ response = await client.list_registrations(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ListRegistrationsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, pagers.ListRegistrationsAsyncPager)
+ assert response.next_page_token == "next_page_token_value"
+
+
+@pytest.mark.asyncio
+async def test_list_registrations_async_from_dict():
+ await test_list_registrations_async(request_type=dict)
+
+
+def test_list_registrations_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ListRegistrationsRequest()
+
+ request.parent = "parent/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ call.return_value = domains.ListRegistrationsResponse()
+ client.list_registrations(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_list_registrations_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ListRegistrationsRequest()
+
+ request.parent = "parent/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.ListRegistrationsResponse()
+ )
+ await client.list_registrations(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"]
+
+
+def test_list_registrations_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.ListRegistrationsResponse()
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.list_registrations(parent="parent_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].parent == "parent_value"
+
+
+def test_list_registrations_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.list_registrations(
+ domains.ListRegistrationsRequest(), parent="parent_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_list_registrations_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.ListRegistrationsResponse()
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.ListRegistrationsResponse()
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.list_registrations(parent="parent_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].parent == "parent_value"
+
+
+@pytest.mark.asyncio
+async def test_list_registrations_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.list_registrations(
+ domains.ListRegistrationsRequest(), parent="parent_value",
+ )
+
+
+def test_list_registrations_pager():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials,)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ # Set the response to a series of pages.
+ call.side_effect = (
+ domains.ListRegistrationsResponse(
+ registrations=[
+ domains.Registration(),
+ domains.Registration(),
+ domains.Registration(),
+ ],
+ next_page_token="abc",
+ ),
+ domains.ListRegistrationsResponse(registrations=[], next_page_token="def",),
+ domains.ListRegistrationsResponse(
+ registrations=[domains.Registration(),], next_page_token="ghi",
+ ),
+ domains.ListRegistrationsResponse(
+ registrations=[domains.Registration(), domains.Registration(),],
+ ),
+ RuntimeError,
+ )
+
+ metadata = ()
+ metadata = tuple(metadata) + (
+ gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)),
+ )
+ pager = client.list_registrations(request={})
+
+ assert pager._metadata == metadata
+
+ results = [i for i in pager]
+ assert len(results) == 6
+ assert all(isinstance(i, domains.Registration) for i in results)
+
+
+def test_list_registrations_pages():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials,)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations), "__call__"
+ ) as call:
+ # Set the response to a series of pages.
+ call.side_effect = (
+ domains.ListRegistrationsResponse(
+ registrations=[
+ domains.Registration(),
+ domains.Registration(),
+ domains.Registration(),
+ ],
+ next_page_token="abc",
+ ),
+ domains.ListRegistrationsResponse(registrations=[], next_page_token="def",),
+ domains.ListRegistrationsResponse(
+ registrations=[domains.Registration(),], next_page_token="ghi",
+ ),
+ domains.ListRegistrationsResponse(
+ registrations=[domains.Registration(), domains.Registration(),],
+ ),
+ RuntimeError,
+ )
+ pages = list(client.list_registrations(request={}).pages)
+ for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
+ assert page_.raw_page.next_page_token == token
+
+
+@pytest.mark.asyncio
+async def test_list_registrations_async_pager():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials,)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations),
+ "__call__",
+ new_callable=mock.AsyncMock,
+ ) as call:
+ # Set the response to a series of pages.
+ call.side_effect = (
+ domains.ListRegistrationsResponse(
+ registrations=[
+ domains.Registration(),
+ domains.Registration(),
+ domains.Registration(),
+ ],
+ next_page_token="abc",
+ ),
+ domains.ListRegistrationsResponse(registrations=[], next_page_token="def",),
+ domains.ListRegistrationsResponse(
+ registrations=[domains.Registration(),], next_page_token="ghi",
+ ),
+ domains.ListRegistrationsResponse(
+ registrations=[domains.Registration(), domains.Registration(),],
+ ),
+ RuntimeError,
+ )
+ async_pager = await client.list_registrations(request={},)
+ assert async_pager.next_page_token == "abc"
+ responses = []
+ async for response in async_pager:
+ responses.append(response)
+
+ assert len(responses) == 6
+ assert all(isinstance(i, domains.Registration) for i in responses)
+
+
+@pytest.mark.asyncio
+async def test_list_registrations_async_pages():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials,)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.list_registrations),
+ "__call__",
+ new_callable=mock.AsyncMock,
+ ) as call:
+ # Set the response to a series of pages.
+ call.side_effect = (
+ domains.ListRegistrationsResponse(
+ registrations=[
+ domains.Registration(),
+ domains.Registration(),
+ domains.Registration(),
+ ],
+ next_page_token="abc",
+ ),
+ domains.ListRegistrationsResponse(registrations=[], next_page_token="def",),
+ domains.ListRegistrationsResponse(
+ registrations=[domains.Registration(),], next_page_token="ghi",
+ ),
+ domains.ListRegistrationsResponse(
+ registrations=[domains.Registration(), domains.Registration(),],
+ ),
+ RuntimeError,
+ )
+ pages = []
+ async for page_ in (await client.list_registrations(request={})).pages:
+ pages.append(page_)
+ for page_, token in zip(pages, ["abc", "def", "ghi", ""]):
+ assert page_.raw_page.next_page_token == token
+
+
+def test_get_registration(
+ transport: str = "grpc", request_type=domains.GetRegistrationRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.get_registration), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.Registration(
+ name="name_value",
+ domain_name="domain_name_value",
+ state=domains.Registration.State.REGISTRATION_PENDING,
+ issues=[domains.Registration.Issue.CONTACT_SUPPORT],
+ supported_privacy=[domains.ContactPrivacy.PUBLIC_CONTACT_DATA],
+ )
+ response = client.get_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.GetRegistrationRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.Registration)
+ assert response.name == "name_value"
+ assert response.domain_name == "domain_name_value"
+ assert response.state == domains.Registration.State.REGISTRATION_PENDING
+ assert response.issues == [domains.Registration.Issue.CONTACT_SUPPORT]
+ assert response.supported_privacy == [domains.ContactPrivacy.PUBLIC_CONTACT_DATA]
+
+
+def test_get_registration_from_dict():
+ test_get_registration(request_type=dict)
+
+
+def test_get_registration_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.get_registration), "__call__") as call:
+ client.get_registration()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.GetRegistrationRequest()
+
+
+@pytest.mark.asyncio
+async def test_get_registration_async(
+ transport: str = "grpc_asyncio", request_type=domains.GetRegistrationRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.get_registration), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.Registration(
+ name="name_value",
+ domain_name="domain_name_value",
+ state=domains.Registration.State.REGISTRATION_PENDING,
+ issues=[domains.Registration.Issue.CONTACT_SUPPORT],
+ supported_privacy=[domains.ContactPrivacy.PUBLIC_CONTACT_DATA],
+ )
+ )
+ response = await client.get_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.GetRegistrationRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.Registration)
+ assert response.name == "name_value"
+ assert response.domain_name == "domain_name_value"
+ assert response.state == domains.Registration.State.REGISTRATION_PENDING
+ assert response.issues == [domains.Registration.Issue.CONTACT_SUPPORT]
+ assert response.supported_privacy == [domains.ContactPrivacy.PUBLIC_CONTACT_DATA]
+
+
+@pytest.mark.asyncio
+async def test_get_registration_async_from_dict():
+ await test_get_registration_async(request_type=dict)
+
+
+def test_get_registration_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.GetRegistrationRequest()
+
+ request.name = "name/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.get_registration), "__call__") as call:
+ call.return_value = domains.Registration()
+ client.get_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "name=name/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_get_registration_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.GetRegistrationRequest()
+
+ request.name = "name/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.get_registration), "__call__") as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.Registration()
+ )
+ await client.get_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "name=name/value",) in kw["metadata"]
+
+
+def test_get_registration_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.get_registration), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.Registration()
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.get_registration(name="name_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].name == "name_value"
+
+
+def test_get_registration_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.get_registration(
+ domains.GetRegistrationRequest(), name="name_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_get_registration_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.get_registration), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.Registration()
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.Registration()
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.get_registration(name="name_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].name == "name_value"
+
+
+@pytest.mark.asyncio
+async def test_get_registration_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.get_registration(
+ domains.GetRegistrationRequest(), name="name_value",
+ )
+
+
+def test_update_registration(
+ transport: str = "grpc", request_type=domains.UpdateRegistrationRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.update_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.UpdateRegistrationRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_update_registration_from_dict():
+ test_update_registration(request_type=dict)
+
+
+def test_update_registration_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_registration), "__call__"
+ ) as call:
+ client.update_registration()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.UpdateRegistrationRequest()
+
+
+@pytest.mark.asyncio
+async def test_update_registration_async(
+ transport: str = "grpc_asyncio", request_type=domains.UpdateRegistrationRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.update_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.UpdateRegistrationRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_update_registration_async_from_dict():
+ await test_update_registration_async(request_type=dict)
+
+
+def test_update_registration_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.UpdateRegistrationRequest()
+
+ request.registration.name = "registration.name/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_registration), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.update_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert (
+ "x-goog-request-params",
+ "registration.name=registration.name/value",
+ ) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_update_registration_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.UpdateRegistrationRequest()
+
+ request.registration.name = "registration.name/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_registration), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.update_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert (
+ "x-goog-request-params",
+ "registration.name=registration.name/value",
+ ) in kw["metadata"]
+
+
+def test_update_registration_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.update_registration(
+ registration=domains.Registration(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == domains.Registration(name="name_value")
+ assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"])
+
+
+def test_update_registration_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.update_registration(
+ domains.UpdateRegistrationRequest(),
+ registration=domains.Registration(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+@pytest.mark.asyncio
+async def test_update_registration_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.update_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.update_registration(
+ registration=domains.Registration(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == domains.Registration(name="name_value")
+ assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"])
+
+
+@pytest.mark.asyncio
+async def test_update_registration_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.update_registration(
+ domains.UpdateRegistrationRequest(),
+ registration=domains.Registration(name="name_value"),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+def test_configure_management_settings(
+ transport: str = "grpc", request_type=domains.ConfigureManagementSettingsRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_management_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.configure_management_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureManagementSettingsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_configure_management_settings_from_dict():
+ test_configure_management_settings(request_type=dict)
+
+
+def test_configure_management_settings_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_management_settings), "__call__"
+ ) as call:
+ client.configure_management_settings()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureManagementSettingsRequest()
+
+
+@pytest.mark.asyncio
+async def test_configure_management_settings_async(
+ transport: str = "grpc_asyncio",
+ request_type=domains.ConfigureManagementSettingsRequest,
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_management_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.configure_management_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureManagementSettingsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_configure_management_settings_async_from_dict():
+ await test_configure_management_settings_async(request_type=dict)
+
+
+def test_configure_management_settings_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ConfigureManagementSettingsRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_management_settings), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.configure_management_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+@pytest.mark.asyncio
+async def test_configure_management_settings_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ConfigureManagementSettingsRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_management_settings), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.configure_management_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+def test_configure_management_settings_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_management_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.configure_management_settings(
+ registration="registration_value",
+ management_settings=domains.ManagementSettings(
+ renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+ assert args[0].management_settings == domains.ManagementSettings(
+ renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL
+ )
+ assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"])
+
+
+def test_configure_management_settings_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.configure_management_settings(
+ domains.ConfigureManagementSettingsRequest(),
+ registration="registration_value",
+ management_settings=domains.ManagementSettings(
+ renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+@pytest.mark.asyncio
+async def test_configure_management_settings_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_management_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.configure_management_settings(
+ registration="registration_value",
+ management_settings=domains.ManagementSettings(
+ renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+ assert args[0].management_settings == domains.ManagementSettings(
+ renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL
+ )
+ assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"])
+
+
+@pytest.mark.asyncio
+async def test_configure_management_settings_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.configure_management_settings(
+ domains.ConfigureManagementSettingsRequest(),
+ registration="registration_value",
+ management_settings=domains.ManagementSettings(
+ renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+def test_configure_dns_settings(
+ transport: str = "grpc", request_type=domains.ConfigureDnsSettingsRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_dns_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.configure_dns_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureDnsSettingsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_configure_dns_settings_from_dict():
+ test_configure_dns_settings(request_type=dict)
+
+
+def test_configure_dns_settings_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_dns_settings), "__call__"
+ ) as call:
+ client.configure_dns_settings()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureDnsSettingsRequest()
+
+
+@pytest.mark.asyncio
+async def test_configure_dns_settings_async(
+ transport: str = "grpc_asyncio", request_type=domains.ConfigureDnsSettingsRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_dns_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.configure_dns_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureDnsSettingsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_configure_dns_settings_async_from_dict():
+ await test_configure_dns_settings_async(request_type=dict)
+
+
+def test_configure_dns_settings_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ConfigureDnsSettingsRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_dns_settings), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.configure_dns_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+@pytest.mark.asyncio
+async def test_configure_dns_settings_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ConfigureDnsSettingsRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_dns_settings), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.configure_dns_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+def test_configure_dns_settings_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_dns_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.configure_dns_settings(
+ registration="registration_value",
+ dns_settings=domains.DnsSettings(
+ custom_dns=domains.DnsSettings.CustomDns(
+ name_servers=["name_servers_value"]
+ )
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+ assert args[0].dns_settings == domains.DnsSettings(
+ custom_dns=domains.DnsSettings.CustomDns(
+ name_servers=["name_servers_value"]
+ )
+ )
+ assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"])
+
+
+def test_configure_dns_settings_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.configure_dns_settings(
+ domains.ConfigureDnsSettingsRequest(),
+ registration="registration_value",
+ dns_settings=domains.DnsSettings(
+ custom_dns=domains.DnsSettings.CustomDns(
+ name_servers=["name_servers_value"]
+ )
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+@pytest.mark.asyncio
+async def test_configure_dns_settings_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_dns_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.configure_dns_settings(
+ registration="registration_value",
+ dns_settings=domains.DnsSettings(
+ custom_dns=domains.DnsSettings.CustomDns(
+ name_servers=["name_servers_value"]
+ )
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+ assert args[0].dns_settings == domains.DnsSettings(
+ custom_dns=domains.DnsSettings.CustomDns(
+ name_servers=["name_servers_value"]
+ )
+ )
+ assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"])
+
+
+@pytest.mark.asyncio
+async def test_configure_dns_settings_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.configure_dns_settings(
+ domains.ConfigureDnsSettingsRequest(),
+ registration="registration_value",
+ dns_settings=domains.DnsSettings(
+ custom_dns=domains.DnsSettings.CustomDns(
+ name_servers=["name_servers_value"]
+ )
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+def test_configure_contact_settings(
+ transport: str = "grpc", request_type=domains.ConfigureContactSettingsRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_contact_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.configure_contact_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureContactSettingsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_configure_contact_settings_from_dict():
+ test_configure_contact_settings(request_type=dict)
+
+
+def test_configure_contact_settings_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_contact_settings), "__call__"
+ ) as call:
+ client.configure_contact_settings()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureContactSettingsRequest()
+
+
+@pytest.mark.asyncio
+async def test_configure_contact_settings_async(
+ transport: str = "grpc_asyncio",
+ request_type=domains.ConfigureContactSettingsRequest,
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_contact_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.configure_contact_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ConfigureContactSettingsRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_configure_contact_settings_async_from_dict():
+ await test_configure_contact_settings_async(request_type=dict)
+
+
+def test_configure_contact_settings_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ConfigureContactSettingsRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_contact_settings), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.configure_contact_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+@pytest.mark.asyncio
+async def test_configure_contact_settings_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ConfigureContactSettingsRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_contact_settings), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.configure_contact_settings(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+def test_configure_contact_settings_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_contact_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.configure_contact_settings(
+ registration="registration_value",
+ contact_settings=domains.ContactSettings(
+ privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+ assert args[0].contact_settings == domains.ContactSettings(
+ privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA
+ )
+ assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"])
+
+
+def test_configure_contact_settings_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.configure_contact_settings(
+ domains.ConfigureContactSettingsRequest(),
+ registration="registration_value",
+ contact_settings=domains.ContactSettings(
+ privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+@pytest.mark.asyncio
+async def test_configure_contact_settings_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.configure_contact_settings), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.configure_contact_settings(
+ registration="registration_value",
+ contact_settings=domains.ContactSettings(
+ privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+ assert args[0].contact_settings == domains.ContactSettings(
+ privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA
+ )
+ assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"])
+
+
+@pytest.mark.asyncio
+async def test_configure_contact_settings_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.configure_contact_settings(
+ domains.ConfigureContactSettingsRequest(),
+ registration="registration_value",
+ contact_settings=domains.ContactSettings(
+ privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA
+ ),
+ update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]),
+ )
+
+
+def test_export_registration(
+ transport: str = "grpc", request_type=domains.ExportRegistrationRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.export_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.export_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ExportRegistrationRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_export_registration_from_dict():
+ test_export_registration(request_type=dict)
+
+
+def test_export_registration_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.export_registration), "__call__"
+ ) as call:
+ client.export_registration()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ExportRegistrationRequest()
+
+
+@pytest.mark.asyncio
+async def test_export_registration_async(
+ transport: str = "grpc_asyncio", request_type=domains.ExportRegistrationRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.export_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.export_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ExportRegistrationRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_export_registration_async_from_dict():
+ await test_export_registration_async(request_type=dict)
+
+
+def test_export_registration_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ExportRegistrationRequest()
+
+ request.name = "name/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.export_registration), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.export_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "name=name/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_export_registration_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ExportRegistrationRequest()
+
+ request.name = "name/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.export_registration), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.export_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "name=name/value",) in kw["metadata"]
+
+
+def test_export_registration_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.export_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.export_registration(name="name_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].name == "name_value"
+
+
+def test_export_registration_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.export_registration(
+ domains.ExportRegistrationRequest(), name="name_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_export_registration_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.export_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.export_registration(name="name_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].name == "name_value"
+
+
+@pytest.mark.asyncio
+async def test_export_registration_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.export_registration(
+ domains.ExportRegistrationRequest(), name="name_value",
+ )
+
+
+def test_delete_registration(
+ transport: str = "grpc", request_type=domains.DeleteRegistrationRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.delete_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.DeleteRegistrationRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_delete_registration_from_dict():
+ test_delete_registration(request_type=dict)
+
+
+def test_delete_registration_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_registration), "__call__"
+ ) as call:
+ client.delete_registration()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.DeleteRegistrationRequest()
+
+
+@pytest.mark.asyncio
+async def test_delete_registration_async(
+ transport: str = "grpc_asyncio", request_type=domains.DeleteRegistrationRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.delete_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.DeleteRegistrationRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_delete_registration_async_from_dict():
+ await test_delete_registration_async(request_type=dict)
+
+
+def test_delete_registration_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.DeleteRegistrationRequest()
+
+ request.name = "name/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_registration), "__call__"
+ ) as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.delete_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "name=name/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_delete_registration_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.DeleteRegistrationRequest()
+
+ request.name = "name/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_registration), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.delete_registration(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "name=name/value",) in kw["metadata"]
+
+
+def test_delete_registration_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.delete_registration(name="name_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].name == "name_value"
+
+
+def test_delete_registration_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.delete_registration(
+ domains.DeleteRegistrationRequest(), name="name_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_delete_registration_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.delete_registration), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.delete_registration(name="name_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].name == "name_value"
+
+
+@pytest.mark.asyncio
+async def test_delete_registration_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.delete_registration(
+ domains.DeleteRegistrationRequest(), name="name_value",
+ )
+
+
+def test_retrieve_authorization_code(
+ transport: str = "grpc", request_type=domains.RetrieveAuthorizationCodeRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_authorization_code), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.AuthorizationCode(code="code_value",)
+ response = client.retrieve_authorization_code(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveAuthorizationCodeRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.AuthorizationCode)
+ assert response.code == "code_value"
+
+
+def test_retrieve_authorization_code_from_dict():
+ test_retrieve_authorization_code(request_type=dict)
+
+
+def test_retrieve_authorization_code_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_authorization_code), "__call__"
+ ) as call:
+ client.retrieve_authorization_code()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveAuthorizationCodeRequest()
+
+
+@pytest.mark.asyncio
+async def test_retrieve_authorization_code_async(
+ transport: str = "grpc_asyncio",
+ request_type=domains.RetrieveAuthorizationCodeRequest,
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_authorization_code), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.AuthorizationCode(code="code_value",)
+ )
+ response = await client.retrieve_authorization_code(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveAuthorizationCodeRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.AuthorizationCode)
+ assert response.code == "code_value"
+
+
+@pytest.mark.asyncio
+async def test_retrieve_authorization_code_async_from_dict():
+ await test_retrieve_authorization_code_async(request_type=dict)
+
+
+def test_retrieve_authorization_code_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RetrieveAuthorizationCodeRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_authorization_code), "__call__"
+ ) as call:
+ call.return_value = domains.AuthorizationCode()
+ client.retrieve_authorization_code(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+@pytest.mark.asyncio
+async def test_retrieve_authorization_code_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RetrieveAuthorizationCodeRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_authorization_code), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.AuthorizationCode()
+ )
+ await client.retrieve_authorization_code(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+def test_retrieve_authorization_code_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_authorization_code), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.AuthorizationCode()
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.retrieve_authorization_code(registration="registration_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+
+
+def test_retrieve_authorization_code_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.retrieve_authorization_code(
+ domains.RetrieveAuthorizationCodeRequest(),
+ registration="registration_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_retrieve_authorization_code_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_authorization_code), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.AuthorizationCode()
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.AuthorizationCode()
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.retrieve_authorization_code(
+ registration="registration_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+
+
+@pytest.mark.asyncio
+async def test_retrieve_authorization_code_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.retrieve_authorization_code(
+ domains.RetrieveAuthorizationCodeRequest(),
+ registration="registration_value",
+ )
+
+
+def test_reset_authorization_code(
+ transport: str = "grpc", request_type=domains.ResetAuthorizationCodeRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.reset_authorization_code), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.AuthorizationCode(code="code_value",)
+ response = client.reset_authorization_code(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ResetAuthorizationCodeRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.AuthorizationCode)
+ assert response.code == "code_value"
+
+
+def test_reset_authorization_code_from_dict():
+ test_reset_authorization_code(request_type=dict)
+
+
+def test_reset_authorization_code_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.reset_authorization_code), "__call__"
+ ) as call:
+ client.reset_authorization_code()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ResetAuthorizationCodeRequest()
+
+
+@pytest.mark.asyncio
+async def test_reset_authorization_code_async(
+ transport: str = "grpc_asyncio", request_type=domains.ResetAuthorizationCodeRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.reset_authorization_code), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.AuthorizationCode(code="code_value",)
+ )
+ response = await client.reset_authorization_code(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.ResetAuthorizationCodeRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.AuthorizationCode)
+ assert response.code == "code_value"
+
+
+@pytest.mark.asyncio
+async def test_reset_authorization_code_async_from_dict():
+ await test_reset_authorization_code_async(request_type=dict)
+
+
+def test_reset_authorization_code_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ResetAuthorizationCodeRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.reset_authorization_code), "__call__"
+ ) as call:
+ call.return_value = domains.AuthorizationCode()
+ client.reset_authorization_code(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+@pytest.mark.asyncio
+async def test_reset_authorization_code_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.ResetAuthorizationCodeRequest()
+
+ request.registration = "registration/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.reset_authorization_code), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.AuthorizationCode()
+ )
+ await client.reset_authorization_code(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "registration=registration/value",) in kw[
+ "metadata"
+ ]
+
+
+def test_reset_authorization_code_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.reset_authorization_code), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.AuthorizationCode()
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.reset_authorization_code(registration="registration_value",)
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+
+
+def test_reset_authorization_code_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.reset_authorization_code(
+ domains.ResetAuthorizationCodeRequest(), registration="registration_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_reset_authorization_code_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.reset_authorization_code), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.AuthorizationCode()
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.AuthorizationCode()
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.reset_authorization_code(
+ registration="registration_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].registration == "registration_value"
+
+
+@pytest.mark.asyncio
+async def test_reset_authorization_code_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.reset_authorization_code(
+ domains.ResetAuthorizationCodeRequest(), registration="registration_value",
+ )
+
+
+def test_credentials_transport_error():
+ # It is an error to provide credentials and a transport instance.
+ transport = transports.DomainsGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # It is an error to provide a credentials file and a transport instance.
+ transport = transports.DomainsGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = DomainsClient(
+ client_options={"credentials_file": "credentials.json"},
+ transport=transport,
+ )
+
+ # It is an error to provide scopes and a transport instance.
+ transport = transports.DomainsGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ with pytest.raises(ValueError):
+ client = DomainsClient(
+ client_options={"scopes": ["1", "2"]}, transport=transport,
+ )
+
+
+def test_transport_instance():
+ # A client may be instantiated with a custom transport instance.
+ transport = transports.DomainsGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ client = DomainsClient(transport=transport)
+ assert client.transport is transport
+
+
+def test_transport_get_channel():
+ # A client may be instantiated with a custom transport instance.
+ transport = transports.DomainsGrpcTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ channel = transport.grpc_channel
+ assert channel
+
+ transport = transports.DomainsGrpcAsyncIOTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+ channel = transport.grpc_channel
+ assert channel
+
+
+@pytest.mark.parametrize(
+ "transport_class",
+ [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport,],
+)
+def test_transport_adc(transport_class):
+ # Test default credentials are used if not provided.
+ with mock.patch.object(google.auth, "default") as adc:
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport_class()
+ adc.assert_called_once()
+
+
+def test_transport_grpc_default():
+ # A client should use the gRPC transport by default.
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+ assert isinstance(client.transport, transports.DomainsGrpcTransport,)
+
+
+def test_domains_base_transport_error():
+ # Passing both a credentials object and credentials_file should raise an error
+ with pytest.raises(core_exceptions.DuplicateCredentialArgs):
+ transport = transports.DomainsTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ credentials_file="credentials.json",
+ )
+
+
+def test_domains_base_transport():
+ # Instantiate the base transport.
+ with mock.patch(
+ "google.cloud.domains_v1.services.domains.transports.DomainsTransport.__init__"
+ ) as Transport:
+ Transport.return_value = None
+ transport = transports.DomainsTransport(
+ credentials=ga_credentials.AnonymousCredentials(),
+ )
+
+ # Every method on the transport should just blindly
+ # raise NotImplementedError.
+ methods = (
+ "search_domains",
+ "retrieve_register_parameters",
+ "register_domain",
+ "retrieve_transfer_parameters",
+ "transfer_domain",
+ "list_registrations",
+ "get_registration",
+ "update_registration",
+ "configure_management_settings",
+ "configure_dns_settings",
+ "configure_contact_settings",
+ "export_registration",
+ "delete_registration",
+ "retrieve_authorization_code",
+ "reset_authorization_code",
+ )
+ for method in methods:
+ with pytest.raises(NotImplementedError):
+ getattr(transport, method)(request=object())
+
+ with pytest.raises(NotImplementedError):
+ transport.close()
+
+ # Additionally, the LRO client (a property) should
+ # also raise NotImplementedError
+ with pytest.raises(NotImplementedError):
+ transport.operations_client
+
+
+@requires_google_auth_gte_1_25_0
+def test_domains_base_transport_with_credentials_file():
+ # Instantiate the base transport with a credentials file
+ with mock.patch.object(
+ google.auth, "load_credentials_from_file", autospec=True
+ ) as load_creds, mock.patch(
+ "google.cloud.domains_v1.services.domains.transports.DomainsTransport._prep_wrapped_messages"
+ ) as Transport:
+ Transport.return_value = None
+ load_creds.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport = transports.DomainsTransport(
+ credentials_file="credentials.json", quota_project_id="octopus",
+ )
+ load_creds.assert_called_once_with(
+ "credentials.json",
+ scopes=None,
+ default_scopes=("https://www.googleapis.com/auth/cloud-platform",),
+ quota_project_id="octopus",
+ )
+
+
+@requires_google_auth_lt_1_25_0
+def test_domains_base_transport_with_credentials_file_old_google_auth():
+ # Instantiate the base transport with a credentials file
+ with mock.patch.object(
+ google.auth, "load_credentials_from_file", autospec=True
+ ) as load_creds, mock.patch(
+ "google.cloud.domains_v1.services.domains.transports.DomainsTransport._prep_wrapped_messages"
+ ) as Transport:
+ Transport.return_value = None
+ load_creds.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport = transports.DomainsTransport(
+ credentials_file="credentials.json", quota_project_id="octopus",
+ )
+ load_creds.assert_called_once_with(
+ "credentials.json",
+ scopes=("https://www.googleapis.com/auth/cloud-platform",),
+ quota_project_id="octopus",
+ )
+
+
+def test_domains_base_transport_with_adc():
+ # Test the default credentials are used if credentials and credentials_file are None.
+ with mock.patch.object(google.auth, "default", autospec=True) as adc, mock.patch(
+ "google.cloud.domains_v1.services.domains.transports.DomainsTransport._prep_wrapped_messages"
+ ) as Transport:
+ Transport.return_value = None
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport = transports.DomainsTransport()
+ adc.assert_called_once()
+
+
+@requires_google_auth_gte_1_25_0
+def test_domains_auth_adc():
+ # If no credentials are provided, we should use ADC credentials.
+ with mock.patch.object(google.auth, "default", autospec=True) as adc:
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ DomainsClient()
+ adc.assert_called_once_with(
+ scopes=None,
+ default_scopes=("https://www.googleapis.com/auth/cloud-platform",),
+ quota_project_id=None,
+ )
+
+
+@requires_google_auth_lt_1_25_0
+def test_domains_auth_adc_old_google_auth():
+ # If no credentials are provided, we should use ADC credentials.
+ with mock.patch.object(google.auth, "default", autospec=True) as adc:
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ DomainsClient()
+ adc.assert_called_once_with(
+ scopes=("https://www.googleapis.com/auth/cloud-platform",),
+ quota_project_id=None,
+ )
+
+
+@pytest.mark.parametrize(
+ "transport_class",
+ [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport,],
+)
+@requires_google_auth_gte_1_25_0
+def test_domains_transport_auth_adc(transport_class):
+ # If credentials and host are not provided, the transport class should use
+ # ADC credentials.
+ with mock.patch.object(google.auth, "default", autospec=True) as adc:
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport_class(quota_project_id="octopus", scopes=["1", "2"])
+ adc.assert_called_once_with(
+ scopes=["1", "2"],
+ default_scopes=("https://www.googleapis.com/auth/cloud-platform",),
+ quota_project_id="octopus",
+ )
+
+
+@pytest.mark.parametrize(
+ "transport_class",
+ [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport,],
+)
+@requires_google_auth_lt_1_25_0
+def test_domains_transport_auth_adc_old_google_auth(transport_class):
+ # If credentials and host are not provided, the transport class should use
+ # ADC credentials.
+ with mock.patch.object(google.auth, "default", autospec=True) as adc:
+ adc.return_value = (ga_credentials.AnonymousCredentials(), None)
+ transport_class(quota_project_id="octopus")
+ adc.assert_called_once_with(
+ scopes=("https://www.googleapis.com/auth/cloud-platform",),
+ quota_project_id="octopus",
+ )
+
+
+@pytest.mark.parametrize(
+ "transport_class,grpc_helpers",
+ [
+ (transports.DomainsGrpcTransport, grpc_helpers),
+ (transports.DomainsGrpcAsyncIOTransport, grpc_helpers_async),
+ ],
+)
+def test_domains_transport_create_channel(transport_class, grpc_helpers):
+ # If credentials and host are not provided, the transport class should use
+ # ADC credentials.
+ with mock.patch.object(
+ google.auth, "default", autospec=True
+ ) as adc, mock.patch.object(
+ grpc_helpers, "create_channel", autospec=True
+ ) as create_channel:
+ creds = ga_credentials.AnonymousCredentials()
+ adc.return_value = (creds, None)
+ transport_class(quota_project_id="octopus", scopes=["1", "2"])
+
+ create_channel.assert_called_with(
+ "domains.googleapis.com:443",
+ credentials=creds,
+ credentials_file=None,
+ quota_project_id="octopus",
+ default_scopes=("https://www.googleapis.com/auth/cloud-platform",),
+ scopes=["1", "2"],
+ default_host="domains.googleapis.com",
+ ssl_credentials=None,
+ options=[
+ ("grpc.max_send_message_length", -1),
+ ("grpc.max_receive_message_length", -1),
+ ],
+ )
+
+
+@pytest.mark.parametrize(
+ "transport_class",
+ [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport],
+)
+def test_domains_grpc_transport_client_cert_source_for_mtls(transport_class):
+ cred = ga_credentials.AnonymousCredentials()
+
+ # Check ssl_channel_credentials is used if provided.
+ with mock.patch.object(transport_class, "create_channel") as mock_create_channel:
+ mock_ssl_channel_creds = mock.Mock()
+ transport_class(
+ host="squid.clam.whelk",
+ credentials=cred,
+ ssl_channel_credentials=mock_ssl_channel_creds,
+ )
+ mock_create_channel.assert_called_once_with(
+ "squid.clam.whelk:443",
+ credentials=cred,
+ credentials_file=None,
+ scopes=None,
+ ssl_credentials=mock_ssl_channel_creds,
+ quota_project_id=None,
+ options=[
+ ("grpc.max_send_message_length", -1),
+ ("grpc.max_receive_message_length", -1),
+ ],
+ )
+
+ # Check if ssl_channel_credentials is not provided, then client_cert_source_for_mtls
+ # is used.
+ with mock.patch.object(transport_class, "create_channel", return_value=mock.Mock()):
+ with mock.patch("grpc.ssl_channel_credentials") as mock_ssl_cred:
+ transport_class(
+ credentials=cred,
+ client_cert_source_for_mtls=client_cert_source_callback,
+ )
+ expected_cert, expected_key = client_cert_source_callback()
+ mock_ssl_cred.assert_called_once_with(
+ certificate_chain=expected_cert, private_key=expected_key
+ )
+
+
+def test_domains_host_no_port():
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ client_options=client_options.ClientOptions(
+ api_endpoint="domains.googleapis.com"
+ ),
+ )
+ assert client.transport._host == "domains.googleapis.com:443"
+
+
+def test_domains_host_with_port():
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(),
+ client_options=client_options.ClientOptions(
+ api_endpoint="domains.googleapis.com:8000"
+ ),
+ )
+ assert client.transport._host == "domains.googleapis.com:8000"
+
+
+def test_domains_grpc_transport_channel():
+ channel = grpc.secure_channel("http://localhost/", grpc.local_channel_credentials())
+
+ # Check that channel is used if provided.
+ transport = transports.DomainsGrpcTransport(
+ host="squid.clam.whelk", channel=channel,
+ )
+ assert transport.grpc_channel == channel
+ assert transport._host == "squid.clam.whelk:443"
+ assert transport._ssl_channel_credentials == None
+
+
+def test_domains_grpc_asyncio_transport_channel():
+ channel = aio.secure_channel("http://localhost/", grpc.local_channel_credentials())
+
+ # Check that channel is used if provided.
+ transport = transports.DomainsGrpcAsyncIOTransport(
+ host="squid.clam.whelk", channel=channel,
+ )
+ assert transport.grpc_channel == channel
+ assert transport._host == "squid.clam.whelk:443"
+ assert transport._ssl_channel_credentials == None
+
+
+# Remove this test when deprecated arguments (api_mtls_endpoint, client_cert_source) are
+# removed from grpc/grpc_asyncio transport constructor.
+@pytest.mark.parametrize(
+ "transport_class",
+ [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport],
+)
+def test_domains_transport_channel_mtls_with_client_cert_source(transport_class):
+ with mock.patch(
+ "grpc.ssl_channel_credentials", autospec=True
+ ) as grpc_ssl_channel_cred:
+ with mock.patch.object(
+ transport_class, "create_channel"
+ ) as grpc_create_channel:
+ mock_ssl_cred = mock.Mock()
+ grpc_ssl_channel_cred.return_value = mock_ssl_cred
+
+ mock_grpc_channel = mock.Mock()
+ grpc_create_channel.return_value = mock_grpc_channel
+
+ cred = ga_credentials.AnonymousCredentials()
+ with pytest.warns(DeprecationWarning):
+ with mock.patch.object(google.auth, "default") as adc:
+ adc.return_value = (cred, None)
+ transport = transport_class(
+ host="squid.clam.whelk",
+ api_mtls_endpoint="mtls.squid.clam.whelk",
+ client_cert_source=client_cert_source_callback,
+ )
+ adc.assert_called_once()
+
+ grpc_ssl_channel_cred.assert_called_once_with(
+ certificate_chain=b"cert bytes", private_key=b"key bytes"
+ )
+ grpc_create_channel.assert_called_once_with(
+ "mtls.squid.clam.whelk:443",
+ credentials=cred,
+ credentials_file=None,
+ scopes=None,
+ ssl_credentials=mock_ssl_cred,
+ quota_project_id=None,
+ options=[
+ ("grpc.max_send_message_length", -1),
+ ("grpc.max_receive_message_length", -1),
+ ],
+ )
+ assert transport.grpc_channel == mock_grpc_channel
+ assert transport._ssl_channel_credentials == mock_ssl_cred
+
+
+# Remove this test when deprecated arguments (api_mtls_endpoint, client_cert_source) are
+# removed from grpc/grpc_asyncio transport constructor.
+@pytest.mark.parametrize(
+ "transport_class",
+ [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport],
+)
+def test_domains_transport_channel_mtls_with_adc(transport_class):
+ mock_ssl_cred = mock.Mock()
+ with mock.patch.multiple(
+ "google.auth.transport.grpc.SslCredentials",
+ __init__=mock.Mock(return_value=None),
+ ssl_credentials=mock.PropertyMock(return_value=mock_ssl_cred),
+ ):
+ with mock.patch.object(
+ transport_class, "create_channel"
+ ) as grpc_create_channel:
+ mock_grpc_channel = mock.Mock()
+ grpc_create_channel.return_value = mock_grpc_channel
+ mock_cred = mock.Mock()
+
+ with pytest.warns(DeprecationWarning):
+ transport = transport_class(
+ host="squid.clam.whelk",
+ credentials=mock_cred,
+ api_mtls_endpoint="mtls.squid.clam.whelk",
+ client_cert_source=None,
+ )
+
+ grpc_create_channel.assert_called_once_with(
+ "mtls.squid.clam.whelk:443",
+ credentials=mock_cred,
+ credentials_file=None,
+ scopes=None,
+ ssl_credentials=mock_ssl_cred,
+ quota_project_id=None,
+ options=[
+ ("grpc.max_send_message_length", -1),
+ ("grpc.max_receive_message_length", -1),
+ ],
+ )
+ assert transport.grpc_channel == mock_grpc_channel
+
+
+def test_domains_grpc_lro_client():
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+ transport = client.transport
+
+ # Ensure that we have a api-core operations client.
+ assert isinstance(transport.operations_client, operations_v1.OperationsClient,)
+
+ # Ensure that subsequent calls to the property send the exact same object.
+ assert transport.operations_client is transport.operations_client
+
+
+def test_domains_grpc_lro_async_client():
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc_asyncio",
+ )
+ transport = client.transport
+
+ # Ensure that we have a api-core operations client.
+ assert isinstance(transport.operations_client, operations_v1.OperationsAsyncClient,)
+
+ # Ensure that subsequent calls to the property send the exact same object.
+ assert transport.operations_client is transport.operations_client
+
+
+def test_registration_path():
+ project = "squid"
+ location = "clam"
+ registration = "whelk"
+ expected = "projects/{project}/locations/{location}/registrations/{registration}".format(
+ project=project, location=location, registration=registration,
+ )
+ actual = DomainsClient.registration_path(project, location, registration)
+ assert expected == actual
+
+
+def test_parse_registration_path():
+ expected = {
+ "project": "octopus",
+ "location": "oyster",
+ "registration": "nudibranch",
+ }
+ path = DomainsClient.registration_path(**expected)
+
+ # Check that the path construction is reversible.
+ actual = DomainsClient.parse_registration_path(path)
+ assert expected == actual
+
+
+def test_common_billing_account_path():
+ billing_account = "cuttlefish"
+ expected = "billingAccounts/{billing_account}".format(
+ billing_account=billing_account,
+ )
+ actual = DomainsClient.common_billing_account_path(billing_account)
+ assert expected == actual
+
+
+def test_parse_common_billing_account_path():
+ expected = {
+ "billing_account": "mussel",
+ }
+ path = DomainsClient.common_billing_account_path(**expected)
+
+ # Check that the path construction is reversible.
+ actual = DomainsClient.parse_common_billing_account_path(path)
+ assert expected == actual
+
+
+def test_common_folder_path():
+ folder = "winkle"
+ expected = "folders/{folder}".format(folder=folder,)
+ actual = DomainsClient.common_folder_path(folder)
+ assert expected == actual
+
+
+def test_parse_common_folder_path():
+ expected = {
+ "folder": "nautilus",
+ }
+ path = DomainsClient.common_folder_path(**expected)
+
+ # Check that the path construction is reversible.
+ actual = DomainsClient.parse_common_folder_path(path)
+ assert expected == actual
+
+
+def test_common_organization_path():
+ organization = "scallop"
+ expected = "organizations/{organization}".format(organization=organization,)
+ actual = DomainsClient.common_organization_path(organization)
+ assert expected == actual
+
+
+def test_parse_common_organization_path():
+ expected = {
+ "organization": "abalone",
+ }
+ path = DomainsClient.common_organization_path(**expected)
+
+ # Check that the path construction is reversible.
+ actual = DomainsClient.parse_common_organization_path(path)
+ assert expected == actual
+
+
+def test_common_project_path():
+ project = "squid"
+ expected = "projects/{project}".format(project=project,)
+ actual = DomainsClient.common_project_path(project)
+ assert expected == actual
+
+
+def test_parse_common_project_path():
+ expected = {
+ "project": "clam",
+ }
+ path = DomainsClient.common_project_path(**expected)
+
+ # Check that the path construction is reversible.
+ actual = DomainsClient.parse_common_project_path(path)
+ assert expected == actual
+
+
+def test_common_location_path():
+ project = "whelk"
+ location = "octopus"
+ expected = "projects/{project}/locations/{location}".format(
+ project=project, location=location,
+ )
+ actual = DomainsClient.common_location_path(project, location)
+ assert expected == actual
+
+
+def test_parse_common_location_path():
+ expected = {
+ "project": "oyster",
+ "location": "nudibranch",
+ }
+ path = DomainsClient.common_location_path(**expected)
+
+ # Check that the path construction is reversible.
+ actual = DomainsClient.parse_common_location_path(path)
+ assert expected == actual
+
+
+def test_client_withDEFAULT_CLIENT_INFO():
+ client_info = gapic_v1.client_info.ClientInfo()
+
+ with mock.patch.object(
+ transports.DomainsTransport, "_prep_wrapped_messages"
+ ) as prep:
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), client_info=client_info,
+ )
+ prep.assert_called_once_with(client_info)
+
+ with mock.patch.object(
+ transports.DomainsTransport, "_prep_wrapped_messages"
+ ) as prep:
+ transport_class = DomainsClient.get_transport_class()
+ transport = transport_class(
+ credentials=ga_credentials.AnonymousCredentials(), client_info=client_info,
+ )
+ prep.assert_called_once_with(client_info)
+
+
+@pytest.mark.asyncio
+async def test_transport_close_async():
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc_asyncio",
+ )
+ with mock.patch.object(
+ type(getattr(client.transport, "grpc_channel")), "close"
+ ) as close:
+ async with client:
+ close.assert_not_called()
+ close.assert_called_once()
+
+
+def test_transport_close():
+ transports = {
+ "grpc": "_grpc_channel",
+ }
+
+ for transport, close_name in transports.items():
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport
+ )
+ with mock.patch.object(
+ type(getattr(client.transport, close_name)), "close"
+ ) as close:
+ with client:
+ close.assert_not_called()
+ close.assert_called_once()
+
+
+def test_client_ctx():
+ transports = [
+ "grpc",
+ ]
+ for transport in transports:
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport
+ )
+ # Test client calls underlying transport.
+ with mock.patch.object(type(client.transport), "close") as close:
+ close.assert_not_called()
+ with client:
+ pass
+ close.assert_called()
diff --git a/packages/google-cloud-domains/tests/unit/gapic/domains_v1beta1/test_domains.py b/packages/google-cloud-domains/tests/unit/gapic/domains_v1beta1/test_domains.py
index c3c2c7d903c4..88d273c63154 100644
--- a/packages/google-cloud-domains/tests/unit/gapic/domains_v1beta1/test_domains.py
+++ b/packages/google-cloud-domains/tests/unit/gapic/domains_v1beta1/test_domains.py
@@ -1106,6 +1106,451 @@ async def test_register_domain_flattened_error_async():
)
+def test_retrieve_transfer_parameters(
+ transport: str = "grpc", request_type=domains.RetrieveTransferParametersRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveTransferParametersResponse()
+ response = client.retrieve_transfer_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveTransferParametersRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.RetrieveTransferParametersResponse)
+
+
+def test_retrieve_transfer_parameters_from_dict():
+ test_retrieve_transfer_parameters(request_type=dict)
+
+
+def test_retrieve_transfer_parameters_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ client.retrieve_transfer_parameters()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveTransferParametersRequest()
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_async(
+ transport: str = "grpc_asyncio",
+ request_type=domains.RetrieveTransferParametersRequest,
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveTransferParametersResponse()
+ )
+ response = await client.retrieve_transfer_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.RetrieveTransferParametersRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, domains.RetrieveTransferParametersResponse)
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_async_from_dict():
+ await test_retrieve_transfer_parameters_async(request_type=dict)
+
+
+def test_retrieve_transfer_parameters_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RetrieveTransferParametersRequest()
+
+ request.location = "location/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ call.return_value = domains.RetrieveTransferParametersResponse()
+ client.retrieve_transfer_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "location=location/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.RetrieveTransferParametersRequest()
+
+ request.location = "location/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveTransferParametersResponse()
+ )
+ await client.retrieve_transfer_parameters(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "location=location/value",) in kw["metadata"]
+
+
+def test_retrieve_transfer_parameters_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveTransferParametersResponse()
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.retrieve_transfer_parameters(
+ location="location_value", domain_name="domain_name_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].location == "location_value"
+ assert args[0].domain_name == "domain_name_value"
+
+
+def test_retrieve_transfer_parameters_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.retrieve_transfer_parameters(
+ domains.RetrieveTransferParametersRequest(),
+ location="location_value",
+ domain_name="domain_name_value",
+ )
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(
+ type(client.transport.retrieve_transfer_parameters), "__call__"
+ ) as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = domains.RetrieveTransferParametersResponse()
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ domains.RetrieveTransferParametersResponse()
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.retrieve_transfer_parameters(
+ location="location_value", domain_name="domain_name_value",
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].location == "location_value"
+ assert args[0].domain_name == "domain_name_value"
+
+
+@pytest.mark.asyncio
+async def test_retrieve_transfer_parameters_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.retrieve_transfer_parameters(
+ domains.RetrieveTransferParametersRequest(),
+ location="location_value",
+ domain_name="domain_name_value",
+ )
+
+
+def test_transfer_domain(
+ transport: str = "grpc", request_type=domains.TransferDomainRequest
+):
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/spam")
+ response = client.transfer_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.TransferDomainRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+def test_transfer_domain_from_dict():
+ test_transfer_domain(request_type=dict)
+
+
+def test_transfer_domain_empty_call():
+ # This test is a coverage failsafe to make sure that totally empty calls,
+ # i.e. request == None and no flattened fields passed, work.
+ client = DomainsClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport="grpc",
+ )
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ client.transfer_domain()
+ call.assert_called()
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.TransferDomainRequest()
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_async(
+ transport: str = "grpc_asyncio", request_type=domains.TransferDomainRequest
+):
+ client = DomainsAsyncClient(
+ credentials=ga_credentials.AnonymousCredentials(), transport=transport,
+ )
+
+ # Everything is optional in proto3 as far as the runtime is concerned,
+ # and we are mocking out the actual API, so just send an empty request.
+ request = request_type()
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ response = await client.transfer_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == domains.TransferDomainRequest()
+
+ # Establish that the response is the type that we expect.
+ assert isinstance(response, future.Future)
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_async_from_dict():
+ await test_transfer_domain_async(request_type=dict)
+
+
+def test_transfer_domain_field_headers():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.TransferDomainRequest()
+
+ request.parent = "parent/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ client.transfer_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"]
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_field_headers_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Any value that is part of the HTTP/1.1 URI should be sent as
+ # a field header. Set these to a non-empty value.
+ request = domains.TransferDomainRequest()
+
+ request.parent = "parent/value"
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/op")
+ )
+ await client.transfer_domain(request)
+
+ # Establish that the underlying gRPC stub method was called.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0] == request
+
+ # Establish that the field header was sent.
+ _, _, kw = call.mock_calls[0]
+ assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"]
+
+
+def test_transfer_domain_flattened():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ client.transfer_domain(
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ authorization_code=domains.AuthorizationCode(code="code_value"),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls) == 1
+ _, args, _ = call.mock_calls[0]
+ assert args[0].parent == "parent_value"
+ assert args[0].registration == domains.Registration(name="name_value")
+ assert args[0].yearly_price == money_pb2.Money(
+ currency_code="currency_code_value"
+ )
+ assert args[0].authorization_code == domains.AuthorizationCode(
+ code="code_value"
+ )
+
+
+def test_transfer_domain_flattened_error():
+ client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ client.transfer_domain(
+ domains.TransferDomainRequest(),
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ authorization_code=domains.AuthorizationCode(code="code_value"),
+ )
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_flattened_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Mock the actual call within the gRPC stub, and fake the request.
+ with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call:
+ # Designate an appropriate return value for the call.
+ call.return_value = operations_pb2.Operation(name="operations/op")
+
+ call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(
+ operations_pb2.Operation(name="operations/spam")
+ )
+ # Call the method with a truthy value for each flattened field,
+ # using the keyword arguments to the method.
+ response = await client.transfer_domain(
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ authorization_code=domains.AuthorizationCode(code="code_value"),
+ )
+
+ # Establish that the underlying call was made with the expected
+ # request object values.
+ assert len(call.mock_calls)
+ _, args, _ = call.mock_calls[0]
+ assert args[0].parent == "parent_value"
+ assert args[0].registration == domains.Registration(name="name_value")
+ assert args[0].yearly_price == money_pb2.Money(
+ currency_code="currency_code_value"
+ )
+ assert args[0].authorization_code == domains.AuthorizationCode(
+ code="code_value"
+ )
+
+
+@pytest.mark.asyncio
+async def test_transfer_domain_flattened_error_async():
+ client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),)
+
+ # Attempting to call a method with both a request object and flattened
+ # fields is an error.
+ with pytest.raises(ValueError):
+ await client.transfer_domain(
+ domains.TransferDomainRequest(),
+ parent="parent_value",
+ registration=domains.Registration(name="name_value"),
+ yearly_price=money_pb2.Money(currency_code="currency_code_value"),
+ authorization_code=domains.AuthorizationCode(code="code_value"),
+ )
+
+
def test_list_registrations(
transport: str = "grpc", request_type=domains.ListRegistrationsRequest
):
@@ -3594,6 +4039,8 @@ def test_domains_base_transport():
"search_domains",
"retrieve_register_parameters",
"register_domain",
+ "retrieve_transfer_parameters",
+ "transfer_domain",
"list_registrations",
"get_registration",
"update_registration",