Class DatastreamAsyncClient (1.9.5)

DatastreamAsyncClient(*, credentials: typing.Optional[google.auth.credentials.Credentials] = None, transport: typing.Optional[typing.Union[str, google.cloud.datastream_v1alpha1.services.datastream.transports.base.DatastreamTransport, typing.Callable[[...], google.cloud.datastream_v1alpha1.services.datastream.transports.base.DatastreamTransport]]] = 'grpc_asyncio', client_options: typing.Optional[google.api_core.client_options.ClientOptions] = None, client_info: google.api_core.gapic_v1.client_info.ClientInfo = <google.api_core.gapic_v1.client_info.ClientInfo object>)

Datastream service

Properties

api_endpoint

Return the API endpoint used by the client instance.

Returns
Type	Description
`str`	The API endpoint used by the client instance.

transport

Returns the transport used by the client instance.

Returns
Type	Description
`DatastreamTransport`	The transport used by the client instance.

universe_domain

Return the universe domain used by the client instance.

Returns
Type	Description
`str`	The universe domain used by the client instance.

Methods

DatastreamAsyncClient

DatastreamAsyncClient(*, credentials: typing.Optional[google.auth.credentials.Credentials] = None, transport: typing.Optional[typing.Union[str, google.cloud.datastream_v1alpha1.services.datastream.transports.base.DatastreamTransport, typing.Callable[[...], google.cloud.datastream_v1alpha1.services.datastream.transports.base.DatastreamTransport]]] = 'grpc_asyncio', client_options: typing.Optional[google.api_core.client_options.ClientOptions] = None, client_info: google.api_core.gapic_v1.client_info.ClientInfo = <google.api_core.gapic_v1.client_info.ClientInfo object>)

Instantiates the datastream async client.

Parameters
Name	Description
`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`	`Optional[Union[str,DatastreamTransport,Callable[..., DatastreamTransport]]]` The transport to use, or a Callable that constructs and returns a new transport to use. If a Callable is given, it will be called with the same set of initialization arguments as used in the DatastreamTransport constructor. If set to None, a transport is chosen automatically.
`client_options`	`Optional[Union[google.api_core.client_options.ClientOptions, dict]]` Custom options for the client. 1. The `api_endpoint` property can be used to override the default endpoint provided by the client when `transport` is not explicitly provided. Only if this property is not set and `transport` was not explicitly provided, the endpoint is determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment variable, which have one of the following values: "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). 2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable is "true", then the `client_cert_source` property can be used to provide a client certificate for mTLS 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. 3. The `universe_domain` property can be used to override the default "googleapis.com" universe. Note that `api_endpoint` property still takes precedence; and `universe_domain` is currently not supported for mTLS.
`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.

Exceptions
Type	Description
`google.auth.exceptions.MutualTlsChannelError`	If mutual TLS transport creation failed for any reason.

common_billing_account_path

common_billing_account_path(billing_account: str) -> str

Returns a fully-qualified billing_account string.

common_folder_path

common_folder_path(folder: str) -> str

Returns a fully-qualified folder string.

common_location_path

common_location_path(project: str, location: str) -> str

Returns a fully-qualified location string.

common_organization_path

common_organization_path(organization: str) -> str

Returns a fully-qualified organization string.

common_project_path

common_project_path(project: str) -> str

Returns a fully-qualified project string.

connection_profile_path

connection_profile_path(
    project: str, location: str, connection_profile: str
) -> str

Returns a fully-qualified connection_profile string.

create_connection_profile

create_connection_profile(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.CreateConnectionProfileRequest,
            dict,
        ]
    ] = None,
    *,
    parent: typing.Optional[str] = None,
    connection_profile: typing.Optional[
        google.cloud.datastream_v1alpha1.types.datastream_resources.ConnectionProfile
    ] = None,
    connection_profile_id: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to create a connection profile in a project and location.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_create_connection_profile():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    connection_profile = datastream_v1alpha1.ConnectionProfile()
    connection_profile.oracle_profile.hostname = "hostname_value"
    connection_profile.oracle_profile.username = "username_value"
    connection_profile.oracle_profile.password = "password_value"
    connection_profile.oracle_profile.database_service = "database_service_value"
    connection_profile.display_name = "display_name_value"

    request = datastream_v1alpha1.CreateConnectionProfileRequest(
        parent="parent_value",
        connection_profile_id="connection_profile_id_value",
        connection_profile=connection_profile,
    )

    # Make the request
    operation = client.create_connection_profile(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.CreateConnectionProfileRequest, dict]]` The request object.
`parent`	`str` Required. The parent that owns the collection of ConnectionProfiles. This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set.
`connection_profile`	`ConnectionProfile` Required. The connection profile resource to create. This corresponds to the `connection_profile` field on the `request` instance; if `request` is provided, this should not be set.
`connection_profile_id`	`str` Required. The connection profile identifier. This corresponds to the `connection_profile_id` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.api_core.operation_async.AsyncOperation`	An object representing a long-running operation. The result type for the operation will be ConnectionProfile

create_private_connection

create_private_connection(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.CreatePrivateConnectionRequest,
            dict,
        ]
    ] = None,
    *,
    parent: typing.Optional[str] = None,
    private_connection: typing.Optional[
        google.cloud.datastream_v1alpha1.types.datastream_resources.PrivateConnection
    ] = None,
    private_connection_id: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to create a private connectivity configuration.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_create_private_connection():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    private_connection = datastream_v1alpha1.PrivateConnection()
    private_connection.display_name = "display_name_value"

    request = datastream_v1alpha1.CreatePrivateConnectionRequest(
        parent="parent_value",
        private_connection_id="private_connection_id_value",
        private_connection=private_connection,
    )

    # Make the request
    operation = client.create_private_connection(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.CreatePrivateConnectionRequest, dict]]` The request object.
`parent`	`str` Required. The parent that owns the collection of PrivateConnections. This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set.
`private_connection`	`PrivateConnection` Required. The Private Connectivity resource to create. This corresponds to the `private_connection` field on the `request` instance; if `request` is provided, this should not be set.
`private_connection_id`	`str` Required. The private connectivity identifier. This corresponds to the `private_connection_id` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.api_core.operation_async.AsyncOperation`	An object representing a long-running operation. The result type for the operation will be PrivateConnection The PrivateConnection resource is used to establish private connectivity between Datastream and a customer's network.

create_route

create_route(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.CreateRouteRequest, dict
        ]
    ] = None,
    *,
    parent: typing.Optional[str] = None,
    route: typing.Optional[
        google.cloud.datastream_v1alpha1.types.datastream_resources.Route
    ] = None,
    route_id: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to create a route for a private connectivity in a project and location.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_create_route():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    route = datastream_v1alpha1.Route()
    route.display_name = "display_name_value"
    route.destination_address = "destination_address_value"

    request = datastream_v1alpha1.CreateRouteRequest(
        parent="parent_value",
        route_id="route_id_value",
        route=route,
    )

    # Make the request
    operation = client.create_route(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.CreateRouteRequest, dict]]` The request object. route creation request
`parent`	`str` Required. The parent that owns the collection of Routes. This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set.
`route`	`Route` Required. The Route resource to create. This corresponds to the `route` field on the `request` instance; if `request` is provided, this should not be set.
`route_id`	`str` Required. The Route identifier. This corresponds to the `route_id` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.api_core.operation_async.AsyncOperation`	An object representing a long-running operation. The result type for the operation will be Route The Route resource is the child of the PrivateConnection resource. It used to define a route for a PrivateConnection setup.

create_stream

create_stream(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.CreateStreamRequest, dict
        ]
    ] = None,
    *,
    parent: typing.Optional[str] = None,
    stream: typing.Optional[
        google.cloud.datastream_v1alpha1.types.datastream_resources.Stream
    ] = None,
    stream_id: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to create a stream.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_create_stream():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    stream = datastream_v1alpha1.Stream()
    stream.display_name = "display_name_value"
    stream.source_config.source_connection_profile_name = "source_connection_profile_name_value"
    stream.destination_config.destination_connection_profile_name = "destination_connection_profile_name_value"

    request = datastream_v1alpha1.CreateStreamRequest(
        parent="parent_value",
        stream_id="stream_id_value",
        stream=stream,
    )

    # Make the request
    operation = client.create_stream(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.CreateStreamRequest, dict]]` The request object.
`parent`	`str` Required. The parent that owns the collection of streams. This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set.
`stream`	`Stream` Required. The stream resource to create. This corresponds to the `stream` field on the `request` instance; if `request` is provided, this should not be set.
`stream_id`	`str` Required. The stream identifier. This corresponds to the `stream_id` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.api_core.operation_async.AsyncOperation`	An object representing a long-running operation. The result type for the operation will be Stream

delete_connection_profile

delete_connection_profile(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.DeleteConnectionProfileRequest,
            dict,
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to delete a connection profile..

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_delete_connection_profile():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.DeleteConnectionProfileRequest(
        name="name_value",
    )

    # Make the request
    operation = client.delete_connection_profile(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.DeleteConnectionProfileRequest, dict]]` The request object.
`name`	`str` Required. The name of the connection profile resource to delete. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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

Type Description

google.api_core.operation_async.AsyncOperation An object representing a long-running operation. The result type for the operation will be 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); }

delete_private_connection

delete_private_connection(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.DeletePrivateConnectionRequest,
            dict,
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to delete a private connectivity configuration.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_delete_private_connection():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.DeletePrivateConnectionRequest(
        name="name_value",
    )

    # Make the request
    operation = client.delete_private_connection(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.DeletePrivateConnectionRequest, dict]]` The request object.
`name`	`str` Required. The name of the private connectivity configuration to delete. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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

Type Description

delete_route

delete_route(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.DeleteRouteRequest, dict
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to delete a route.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_delete_route():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.DeleteRouteRequest(
        name="name_value",
    )

    # Make the request
    operation = client.delete_route(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.DeleteRouteRequest, dict]]` The request object. route deletion request
`name`	`str` Required. The name of the Route resource to delete. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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

Type Description

delete_stream

delete_stream(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.DeleteStreamRequest, dict
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to delete a stream.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_delete_stream():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.DeleteStreamRequest(
        name="name_value",
    )

    # Make the request
    operation = client.delete_stream(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.DeleteStreamRequest, dict]]` The request object.
`name`	`str` Required. The name of the stream resource to delete. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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

Type Description

discover_connection_profile

discover_connection_profile(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.DiscoverConnectionProfileRequest,
            dict,
        ]
    ] = None,
    *,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> (
    google.cloud.datastream_v1alpha1.types.datastream.DiscoverConnectionProfileResponse
)

Use this method to discover a connection profile. The discover API call exposes the data objects and metadata belonging to the profile. Typically, a request returns children data objects under a parent data object that's optionally supplied in the request.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_discover_connection_profile():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    connection_profile = datastream_v1alpha1.ConnectionProfile()
    connection_profile.oracle_profile.hostname = "hostname_value"
    connection_profile.oracle_profile.username = "username_value"
    connection_profile.oracle_profile.password = "password_value"
    connection_profile.oracle_profile.database_service = "database_service_value"
    connection_profile.display_name = "display_name_value"

    request = datastream_v1alpha1.DiscoverConnectionProfileRequest(
        connection_profile=connection_profile,
        recursive=True,
        parent="parent_value",
    )

    # Make the request
    response = await client.discover_connection_profile(request=request)

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.DiscoverConnectionProfileRequest, dict]]` The request object. Request message for 'discover' ConnectionProfile request.
`retry`	`google.api_core.retry_async.AsyncRetry` 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.

fetch_errors

fetch_errors(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.FetchErrorsRequest, dict
        ]
    ] = None,
    *,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to fetch any errors associated with a stream.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_fetch_errors():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.FetchErrorsRequest(
    )

    # Make the request
    operation = client.fetch_errors(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.FetchErrorsRequest, dict]]` The request object. Request message for 'FetchErrors' request.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.api_core.operation_async.AsyncOperation`	An object representing a long-running operation. The result type for the operation will be FetchErrorsResponse Response message for a 'FetchErrors' response.

fetch_static_ips

fetch_static_ips(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.FetchStaticIpsRequest,
            dict,
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> (
    google.cloud.datastream_v1alpha1.services.datastream.pagers.FetchStaticIpsAsyncPager
)

The FetchStaticIps API call exposes the static ips used by Datastream. Typically, a request returns children data objects under a parent data object that's optionally supplied in the request.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_fetch_static_ips():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.FetchStaticIpsRequest(
        name="name_value",
    )

    # Make the request
    page_result = client.fetch_static_ips(request=request)

    # Handle the response
    async for response in page_result:
        print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.FetchStaticIpsRequest, dict]]` The request object. Request message for 'FetchStaticIps' request.
`name`	`str` Required. The name resource of the Response type. Must be in the format `projects//locations/`. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.cloud.datastream_v1alpha1.services.datastream.pagers.FetchStaticIpsAsyncPager`	Response message for a 'FetchStaticIps' response. Iterating over this object will yield results and resolve additional pages automatically.

from_service_account_file

from_service_account_file(filename: str, *args, **kwargs)

Creates an instance of this client using the provided credentials file.

Parameter
Name	Description
`filename`	`str` The path to the service account private key json file.

Returns
Type	Description
`DatastreamAsyncClient`	The constructed client.

from_service_account_info

from_service_account_info(info: dict, *args, **kwargs)

Creates an instance of this client using the provided credentials info.

Parameter
Name	Description
`info`	`dict` The service account private key info.

Returns
Type	Description
`DatastreamAsyncClient`	The constructed client.

from_service_account_json

from_service_account_json(filename: str, *args, **kwargs)

Creates an instance of this client using the provided credentials file.

Parameter
Name	Description
`filename`	`str` The path to the service account private key json file.

Returns
Type	Description
`DatastreamAsyncClient`	The constructed client.

get_connection_profile

get_connection_profile(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.GetConnectionProfileRequest,
            dict,
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.cloud.datastream_v1alpha1.types.datastream_resources.ConnectionProfile

Use this method to get details about a connection profile.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_get_connection_profile():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.GetConnectionProfileRequest(
        name="name_value",
    )

    # Make the request
    response = await client.get_connection_profile(request=request)

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.GetConnectionProfileRequest, dict]]` The request object.
`name`	`str` Required. The name of the connection profile resource to get. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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.

get_mtls_endpoint_and_cert_source

get_mtls_endpoint_and_cert_source(
    client_options: typing.Optional[
        google.api_core.client_options.ClientOptions
    ] = None,
)

Return the API endpoint and client cert source for mutual TLS.

The client cert source is determined in the following order: (1) if GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable is not "true", the client cert source is None. (2) if client_options.client_cert_source is provided, use the provided one; if the default client cert source exists, use the default one; otherwise the client cert source is None.

The API endpoint is determined in the following order: (1) if client_options.api_endpoint if provided, use the provided one. (2) if GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable is "always", use the default mTLS endpoint; if the environment variable is "never", use the default API endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise use the default API endpoint.

More details can be found at https://google.aip.dev/auth/4114.

Parameter
Name	Description
`client_options`	`google.api_core.client_options.ClientOptions` Custom options for the client. Only the `api_endpoint` and `client_cert_source` properties may be used in this method.

Exceptions
Type	Description
`google.auth.exceptions.MutualTLSChannelError`	If any errors happen.

Returns
Type	Description
`Tuple[str, Callable[[], Tuple[bytes, bytes]]]`	returns the API endpoint and the client cert source to use.

get_private_connection

get_private_connection(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.GetPrivateConnectionRequest,
            dict,
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.cloud.datastream_v1alpha1.types.datastream_resources.PrivateConnection

Use this method to get details about a private connectivity configuration.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_get_private_connection():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.GetPrivateConnectionRequest(
        name="name_value",
    )

    # Make the request
    response = await client.get_private_connection(request=request)

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.GetPrivateConnectionRequest, dict]]` The request object.
`name`	`str` Required. The name of the private connectivity configuration to get. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.cloud.datastream_v1alpha1.types.PrivateConnection`	The PrivateConnection resource is used to establish private connectivity between Datastream and a customer's network.

get_route

get_route(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.GetRouteRequest, dict
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.cloud.datastream_v1alpha1.types.datastream_resources.Route

Use this method to get details about a route.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_get_route():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.GetRouteRequest(
        name="name_value",
    )

    # Make the request
    response = await client.get_route(request=request)

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.GetRouteRequest, dict]]` The request object. route get request
`name`	`str` Required. The name of the Route resource to get. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.cloud.datastream_v1alpha1.types.Route`	The Route resource is the child of the PrivateConnection resource. It used to define a route for a PrivateConnection setup.

get_stream

get_stream(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.GetStreamRequest, dict
        ]
    ] = None,
    *,
    name: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.cloud.datastream_v1alpha1.types.datastream_resources.Stream

Use this method to get details about a stream.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_get_stream():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.GetStreamRequest(
        name="name_value",
    )

    # Make the request
    response = await client.get_stream(request=request)

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.GetStreamRequest, dict]]` The request object.
`name`	`str` Required. The name of the stream resource to get. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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.

get_transport_class

get_transport_class() -> (
    typing.Type[
        google.cloud.datastream_v1alpha1.services.datastream.transports.base.DatastreamTransport
    ]
)

Returns an appropriate transport class.

Parameter
Name	Description
`label`	`typing.Optional[str]` The name of the desired transport. If none is provided, then the first transport in the registry is used.

list_connection_profiles

list_connection_profiles(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.ListConnectionProfilesRequest,
            dict,
        ]
    ] = None,
    *,
    parent: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> (
    google.cloud.datastream_v1alpha1.services.datastream.pagers.ListConnectionProfilesAsyncPager
)

Use this method to list connection profiles created in a project and location.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_list_connection_profiles():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.ListConnectionProfilesRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_connection_profiles(request=request)

    # Handle the response
    async for response in page_result:
        print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.ListConnectionProfilesRequest, dict]]` The request object.
`parent`	`str` Required. The parent that owns the collection of connection profiles. This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.cloud.datastream_v1alpha1.services.datastream.pagers.ListConnectionProfilesAsyncPager`	Iterating over this object will yield results and resolve additional pages automatically.

list_private_connections

list_private_connections(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.ListPrivateConnectionsRequest,
            dict,
        ]
    ] = None,
    *,
    parent: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> (
    google.cloud.datastream_v1alpha1.services.datastream.pagers.ListPrivateConnectionsAsyncPager
)

Use this method to list private connectivity configurations in a project and location.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_list_private_connections():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.ListPrivateConnectionsRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_private_connections(request=request)

    # Handle the response
    async for response in page_result:
        print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.ListPrivateConnectionsRequest, dict]]` The request object.
`parent`	`str` Required. The parent that owns the collection of private connectivity configurations. This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.cloud.datastream_v1alpha1.services.datastream.pagers.ListPrivateConnectionsAsyncPager`	Iterating over this object will yield results and resolve additional pages automatically.

list_routes

list_routes(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.ListRoutesRequest, dict
        ]
    ] = None,
    *,
    parent: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.cloud.datastream_v1alpha1.services.datastream.pagers.ListRoutesAsyncPager

Use this method to list routes created for a private connectivity in a project and location.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_list_routes():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.ListRoutesRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_routes(request=request)

    # Handle the response
    async for response in page_result:
        print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.ListRoutesRequest, dict]]` The request object. route list request
`parent`	`str` Required. The parent that owns the collection of Routess. This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.cloud.datastream_v1alpha1.services.datastream.pagers.ListRoutesAsyncPager`	route list response Iterating over this object will yield results and resolve additional pages automatically.

list_streams

list_streams(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.ListStreamsRequest, dict
        ]
    ] = None,
    *,
    parent: typing.Optional[str] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.cloud.datastream_v1alpha1.services.datastream.pagers.ListStreamsAsyncPager

Use this method to list streams in a project and location.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_list_streams():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    request = datastream_v1alpha1.ListStreamsRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_streams(request=request)

    # Handle the response
    async for response in page_result:
        print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.ListStreamsRequest, dict]]` The request object.
`parent`	`str` Required. The parent that owns the collection of streams. This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set.
`retry`	`google.api_core.retry_async.AsyncRetry` 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
Type	Description
`google.cloud.datastream_v1alpha1.services.datastream.pagers.ListStreamsAsyncPager`	Iterating over this object will yield results and resolve additional pages automatically.

parse_common_billing_account_path

parse_common_billing_account_path(path: str) -> typing.Dict[str, str]

Parse a billing_account path into its component segments.

parse_common_folder_path

parse_common_folder_path(path: str) -> typing.Dict[str, str]

Parse a folder path into its component segments.

parse_common_location_path

parse_common_location_path(path: str) -> typing.Dict[str, str]

Parse a location path into its component segments.

parse_common_organization_path

parse_common_organization_path(path: str) -> typing.Dict[str, str]

Parse a organization path into its component segments.

parse_common_project_path

parse_common_project_path(path: str) -> typing.Dict[str, str]

Parse a project path into its component segments.

parse_connection_profile_path

parse_connection_profile_path(path: str) -> typing.Dict[str, str]

Parses a connection_profile path into its component segments.

parse_private_connection_path

parse_private_connection_path(path: str) -> typing.Dict[str, str]

Parses a private_connection path into its component segments.

parse_route_path

parse_route_path(path: str) -> typing.Dict[str, str]

Parses a route path into its component segments.

parse_stream_path

parse_stream_path(path: str) -> typing.Dict[str, str]

Parses a stream path into its component segments.

private_connection_path

private_connection_path(
    project: str, location: str, private_connection: str
) -> str

Returns a fully-qualified private_connection string.

route_path

route_path(project: str, location: str, private_connection: str, route: str) -> str

Returns a fully-qualified route string.

stream_path

stream_path(project: str, location: str, stream: str) -> str

Returns a fully-qualified stream string.

update_connection_profile

update_connection_profile(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.UpdateConnectionProfileRequest,
            dict,
        ]
    ] = None,
    *,
    connection_profile: typing.Optional[
        google.cloud.datastream_v1alpha1.types.datastream_resources.ConnectionProfile
    ] = None,
    update_mask: typing.Optional[google.protobuf.field_mask_pb2.FieldMask] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to update the parameters of a connection profile.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_update_connection_profile():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    connection_profile = datastream_v1alpha1.ConnectionProfile()
    connection_profile.oracle_profile.hostname = "hostname_value"
    connection_profile.oracle_profile.username = "username_value"
    connection_profile.oracle_profile.password = "password_value"
    connection_profile.oracle_profile.database_service = "database_service_value"
    connection_profile.display_name = "display_name_value"

    request = datastream_v1alpha1.UpdateConnectionProfileRequest(
        connection_profile=connection_profile,
    )

    # Make the request
    operation = client.update_connection_profile(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.UpdateConnectionProfileRequest, dict]]` The request object.
`connection_profile`	`ConnectionProfile` Required. The ConnectionProfile to update. This corresponds to the `connection_profile` field on the `request` instance; if `request` is provided, this should not be set.
`update_mask`	`google.protobuf.field_mask_pb2.FieldMask` Optional. Field mask is used to specify the fields to be overwritten in the ConnectionProfile resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten. 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_async.AsyncRetry` 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
Type	Description
`google.api_core.operation_async.AsyncOperation`	An object representing a long-running operation. The result type for the operation will be ConnectionProfile

update_stream

update_stream(
    request: typing.Optional[
        typing.Union[
            google.cloud.datastream_v1alpha1.types.datastream.UpdateStreamRequest, dict
        ]
    ] = None,
    *,
    stream: typing.Optional[
        google.cloud.datastream_v1alpha1.types.datastream_resources.Stream
    ] = None,
    update_mask: typing.Optional[google.protobuf.field_mask_pb2.FieldMask] = None,
    retry: typing.Optional[
        typing.Union[
            google.api_core.retry.retry_unary_async.AsyncRetry,
            google.api_core.gapic_v1.method._MethodDefault,
        ]
    ] = _MethodDefault._DEFAULT_VALUE,
    timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
    metadata: typing.Sequence[typing.Tuple[str, str]] = ()
) -> google.api_core.operation_async.AsyncOperation

Use this method to update the configuration of a stream.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import datastream_v1alpha1

async def sample_update_stream():
    # Create a client
    client = datastream_v1alpha1.DatastreamAsyncClient()

    # Initialize request argument(s)
    stream = datastream_v1alpha1.Stream()
    stream.display_name = "display_name_value"
    stream.source_config.source_connection_profile_name = "source_connection_profile_name_value"
    stream.destination_config.destination_connection_profile_name = "destination_connection_profile_name_value"

    request = datastream_v1alpha1.UpdateStreamRequest(
        stream=stream,
    )

    # Make the request
    operation = client.update_stream(request=request)

    print("Waiting for operation to complete...")

    response = (await operation).result()

    # Handle the response
    print(response)

Parameters
Name	Description
`request`	`Optional[Union[google.cloud.datastream_v1alpha1.types.UpdateStreamRequest, dict]]` The request object.
`stream`	`Stream` Required. The stream resource to update. This corresponds to the `stream` field on the `request` instance; if `request` is provided, this should not be set.
`update_mask`	`google.protobuf.field_mask_pb2.FieldMask` Optional. Field mask is used to specify the fields to be overwritten in the stream resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten. 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_async.AsyncRetry` 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
Type	Description
`google.api_core.operation_async.AsyncOperation`	An object representing a long-running operation. The result type for the operation will be Stream