AutoMlAsyncClient(*, credentials: Optional[google.auth.credentials.Credentials] = None, transport: Union[str, google.cloud.automl_v1.services.auto_ml.transports.base.AutoMlTransport] = 'grpc_asyncio', client_options: 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>)
AutoML Server API.
The resource names are assigned by the server. The server never reuses names that it has created after the resources with those names are deleted.
An ID of a resource is the last element of the item's resource name.
For
projects/{project_id}/locations/{location_id}/datasets/{dataset_id}
,
then the id for the item is {dataset_id}
.
Currently the only supported location_id
is "us-central1".
On any input that is documented to expect a string parameter in snake_case or dash-case, either of those cases is accepted.
Inheritance
builtins.object > AutoMlAsyncClientProperties
transport
Returns the transport used by the client instance.
Type | Description |
AutoMlTransport | The transport used by the client instance. |
Methods
AutoMlAsyncClient
AutoMlAsyncClient(*, credentials: Optional[google.auth.credentials.Credentials] = None, transport: Union[str, google.cloud.automl_v1.services.auto_ml.transports.base.AutoMlTransport] = 'grpc_asyncio', client_options: 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 auto ml client.
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 |
Union[str, `.AutoMlTransport`]
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 |
Type | Description |
google.auth.exceptions.MutualTlsChannelError | If mutual TLS transport creation failed for any reason. |
annotation_spec_path
annotation_spec_path(
project: str, location: str, dataset: str, annotation_spec: str
)
Returns a fully-qualified annotation_spec string.
common_billing_account_path
common_billing_account_path(billing_account: str)
Returns a fully-qualified billing_account string.
common_folder_path
common_folder_path(folder: str)
Returns a fully-qualified folder string.
common_location_path
common_location_path(project: str, location: str)
Returns a fully-qualified location string.
common_organization_path
common_organization_path(organization: str)
Returns a fully-qualified organization string.
common_project_path
common_project_path(project: str)
Returns a fully-qualified project string.
create_dataset
create_dataset(request: Optional[Union[google.cloud.automl_v1.types.service.CreateDatasetRequest, dict]] = None, *, parent: Optional[str] = None, dataset: Optional[google.cloud.automl_v1.types.dataset.Dataset] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Creates a dataset.
from google.cloud import automl_v1
async def sample_create_dataset():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
dataset = automl_v1.Dataset()
dataset.translation_dataset_metadata.source_language_code = "source_language_code_value"
dataset.translation_dataset_metadata.target_language_code = "target_language_code_value"
request = automl_v1.CreateDatasetRequest(
parent="parent_value",
dataset=dataset,
)
# Make the request
operation = client.create_dataset(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.CreateDatasetRequest, dict]
The request object. Request message for AutoMl.CreateDataset. |
parent |
`str`
Required. The resource name of the project to create the dataset for. This corresponds to the |
dataset |
Dataset
Required. The dataset to create. This corresponds to the |
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. |
Type | Description |
google.api_core.operation_async.AsyncOperation | An object representing a long-running operation. The result type for the operation will be Dataset A workspace for solving a single, particular machine learning (ML) problem. A workspace contains examples that may be annotated. |
create_model
create_model(request: Optional[Union[google.cloud.automl_v1.types.service.CreateModelRequest, dict]] = None, *, parent: Optional[str] = None, model: Optional[google.cloud.automl_v1.types.model.Model] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Creates a model. Returns a Model in the
response][google.longrunning.Operation.response]
field when it
completes. When you create a model, several model evaluations
are created for it: a global evaluation, and one evaluation for
each annotation spec.
from google.cloud import automl_v1
async def sample_create_model():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.CreateModelRequest(
parent="parent_value",
)
# Make the request
operation = client.create_model(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.CreateModelRequest, dict]
The request object. Request message for AutoMl.CreateModel. |
parent |
`str`
Required. Resource name of the parent project where the model is being created. This corresponds to the |
model |
Model
Required. The model to create. This corresponds to the |
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. |
Type | Description |
google.api_core.operation_async.AsyncOperation | An object representing a long-running operation. The result type for the operation will be Model API proto representing a trained machine learning model. |
dataset_path
dataset_path(project: str, location: str, dataset: str)
Returns a fully-qualified dataset string.
delete_dataset
delete_dataset(request: Optional[Union[google.cloud.automl_v1.types.service.DeleteDatasetRequest, dict]] = None, *, name: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Deletes a dataset and all of its contents. Returns empty
response in the
response][google.longrunning.Operation.response]
field when it
completes, and delete_details
in the
metadata][google.longrunning.Operation.metadata]
field.
from google.cloud import automl_v1
async def sample_delete_dataset():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.DeleteDatasetRequest(
name="name_value",
)
# Make the request
operation = client.delete_dataset(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.DeleteDatasetRequest, dict]
The request object. Request message for AutoMl.DeleteDataset. |
name |
`str`
Required. The resource name of the dataset to delete. This corresponds to the |
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. |
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); } The JSON representation for Empty is empty JSON object {}. |
delete_model
delete_model(request: Optional[Union[google.cloud.automl_v1.types.service.DeleteModelRequest, dict]] = None, *, name: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Deletes a model. Returns google.protobuf.Empty
in the
response][google.longrunning.Operation.response]
field when it
completes, and delete_details
in the
metadata][google.longrunning.Operation.metadata]
field.
from google.cloud import automl_v1
async def sample_delete_model():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.DeleteModelRequest(
name="name_value",
)
# Make the request
operation = client.delete_model(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.DeleteModelRequest, dict]
The request object. Request message for AutoMl.DeleteModel. |
name |
`str`
Required. Resource name of the model being deleted. This corresponds to the |
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. |
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); } The JSON representation for Empty is empty JSON object {}. |
deploy_model
deploy_model(request: Optional[Union[google.cloud.automl_v1.types.service.DeployModelRequest, dict]] = None, *, name: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Deploys a model. If a model is already deployed, deploying it with the same parameters has no effect. Deploying with different parametrs (as e.g. changing xref_node_number) will reset the deployment state without pausing the model's availability.
Only applicable for Text Classification, Image Object Detection , Tables, and Image Segmentation; all other domains manage deployment automatically.
Returns an empty response in the
response][google.longrunning.Operation.response]
field when it
completes.
from google.cloud import automl_v1
async def sample_deploy_model():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.DeployModelRequest(
name="name_value",
)
# Make the request
operation = client.deploy_model(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.DeployModelRequest, dict]
The request object. Request message for AutoMl.DeployModel. |
name |
`str`
Required. Resource name of the model to deploy. This corresponds to the |
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. |
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); } The JSON representation for Empty is empty JSON object {}. |
export_data
export_data(request: Optional[Union[google.cloud.automl_v1.types.service.ExportDataRequest, dict]] = None, *, name: Optional[str] = None, output_config: Optional[google.cloud.automl_v1.types.io.OutputConfig] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Exports dataset's data to the provided output location. Returns
an empty response in the
response][google.longrunning.Operation.response]
field when it
completes.
from google.cloud import automl_v1
async def sample_export_data():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
output_config = automl_v1.OutputConfig()
output_config.gcs_destination.output_uri_prefix = "output_uri_prefix_value"
request = automl_v1.ExportDataRequest(
name="name_value",
output_config=output_config,
)
# Make the request
operation = client.export_data(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.ExportDataRequest, dict]
The request object. Request message for AutoMl.ExportData. |
name |
`str`
Required. The resource name of the dataset. This corresponds to the |
output_config |
OutputConfig
Required. The desired output location. This corresponds to the |
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. |
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); } The JSON representation for Empty is empty JSON object {}. |
export_model
export_model(request: Optional[Union[google.cloud.automl_v1.types.service.ExportModelRequest, dict]] = None, *, name: Optional[str] = None, output_config: Optional[google.cloud.automl_v1.types.io.ModelExportOutputConfig] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Exports a trained, "export-able", model to a user specified Google Cloud Storage location. A model is considered export-able if and only if it has an export format defined for it in xref_ModelExportOutputConfig.
Returns an empty response in the
response][google.longrunning.Operation.response]
field when it
completes.
from google.cloud import automl_v1
async def sample_export_model():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
output_config = automl_v1.ModelExportOutputConfig()
output_config.gcs_destination.output_uri_prefix = "output_uri_prefix_value"
request = automl_v1.ExportModelRequest(
name="name_value",
output_config=output_config,
)
# Make the request
operation = client.export_model(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.ExportModelRequest, dict]
The request object. Request message for AutoMl.ExportModel. Models need to be enabled for exporting, otherwise an error code will be returned. |
name |
`str`
Required. The resource name of the model to export. This corresponds to the |
output_config |
ModelExportOutputConfig
Required. The desired output location and configuration. This corresponds to the |
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. |
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); } The JSON representation for Empty is empty JSON object {}. |
from_service_account_file
from_service_account_file(filename: str, *args, **kwargs)
Creates an instance of this client using the provided credentials file.
Name | Description |
filename |
str
The path to the service account private key json file. |
Type | Description |
AutoMlAsyncClient | 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.
Name | Description |
info |
dict
The service account private key info. |
Type | Description |
AutoMlAsyncClient | 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.
Name | Description |
filename |
str
The path to the service account private key json file. |
Type | Description |
AutoMlAsyncClient | The constructed client. |
get_annotation_spec
get_annotation_spec(request: Optional[Union[google.cloud.automl_v1.types.service.GetAnnotationSpecRequest, dict]] = None, *, name: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Gets an annotation spec.
from google.cloud import automl_v1
async def sample_get_annotation_spec():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.GetAnnotationSpecRequest(
name="name_value",
)
# Make the request
response = await client.get_annotation_spec(request=request)
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.GetAnnotationSpecRequest, dict]
The request object. Request message for AutoMl.GetAnnotationSpec. |
name |
`str`
Required. The resource name of the annotation spec to retrieve. This corresponds to the |
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. |
Type | Description |
google.cloud.automl_v1.types.AnnotationSpec | A definition of an annotation spec. |
get_dataset
get_dataset(request: Optional[Union[google.cloud.automl_v1.types.service.GetDatasetRequest, dict]] = None, *, name: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Gets a dataset.
from google.cloud import automl_v1
async def sample_get_dataset():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.GetDatasetRequest(
name="name_value",
)
# Make the request
response = await client.get_dataset(request=request)
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.GetDatasetRequest, dict]
The request object. Request message for AutoMl.GetDataset. |
name |
`str`
Required. The resource name of the dataset to retrieve. This corresponds to the |
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. |
Type | Description |
google.cloud.automl_v1.types.Dataset | A workspace for solving a single, particular machine learning (ML) problem. A workspace contains examples that may be annotated. |
get_model
get_model(request: Optional[Union[google.cloud.automl_v1.types.service.GetModelRequest, dict]] = None, *, name: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Gets a model.
from google.cloud import automl_v1
async def sample_get_model():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.GetModelRequest(
name="name_value",
)
# Make the request
response = await client.get_model(request=request)
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.GetModelRequest, dict]
The request object. Request message for AutoMl.GetModel. |
name |
`str`
Required. Resource name of the model. This corresponds to the |
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. |
Type | Description |
google.cloud.automl_v1.types.Model | API proto representing a trained machine learning model. |
get_model_evaluation
get_model_evaluation(request: Optional[Union[google.cloud.automl_v1.types.service.GetModelEvaluationRequest, dict]] = None, *, name: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Gets a model evaluation.
from google.cloud import automl_v1
async def sample_get_model_evaluation():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.GetModelEvaluationRequest(
name="name_value",
)
# Make the request
response = await client.get_model_evaluation(request=request)
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.GetModelEvaluationRequest, dict]
The request object. Request message for AutoMl.GetModelEvaluation. |
name |
`str`
Required. Resource name for the model evaluation. This corresponds to the |
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. |
Type | Description |
google.cloud.automl_v1.types.ModelEvaluation | Evaluation results of a model. |
get_mtls_endpoint_and_cert_source
get_mtls_endpoint_and_cert_source(
client_options: 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 variabel 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.
Name | Description |
client_options |
google.api_core.client_options.ClientOptions
Custom options for the client. Only the |
Type | Description |
google.auth.exceptions.MutualTLSChannelError | If any errors happen. |
Type | Description |
Tuple[str, Callable[[], Tuple[bytes, bytes]]] | returns the API endpoint and the client cert source to use. |
get_transport_class
get_transport_class()
Returns an appropriate transport class.
import_data
import_data(request: Optional[Union[google.cloud.automl_v1.types.service.ImportDataRequest, dict]] = None, *, name: Optional[str] = None, input_config: Optional[google.cloud.automl_v1.types.io.InputConfig] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Imports data into a dataset. For Tables this method can only be called on an empty Dataset.
For Tables:
- A
xref_schema_inference_version
parameter must be explicitly set. Returns an empty response
in the
response][google.longrunning.Operation.response]
field when it completes.
from google.cloud import automl_v1
async def sample_import_data():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
input_config = automl_v1.InputConfig()
input_config.gcs_source.input_uris = ['input_uris_value_1', 'input_uris_value_2']
request = automl_v1.ImportDataRequest(
name="name_value",
input_config=input_config,
)
# Make the request
operation = client.import_data(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.ImportDataRequest, dict]
The request object. Request message for AutoMl.ImportData. |
name |
`str`
Required. Dataset name. Dataset must already exist. All imported annotations and examples will be added. This corresponds to the |
input_config |
InputConfig
Required. The desired input location and its domain specific semantics, if any. This corresponds to the |
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. |
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); } The JSON representation for Empty is empty JSON object {}. |
list_datasets
list_datasets(request: Optional[Union[google.cloud.automl_v1.types.service.ListDatasetsRequest, dict]] = None, *, parent: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Lists datasets in a project.
from google.cloud import automl_v1
async def sample_list_datasets():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.ListDatasetsRequest(
parent="parent_value",
)
# Make the request
page_result = client.list_datasets(request=request)
# Handle the response
async for response in page_result:
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.ListDatasetsRequest, dict]
The request object. Request message for AutoMl.ListDatasets. |
parent |
`str`
Required. The resource name of the project from which to list datasets. This corresponds to the |
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. |
Type | Description |
google.cloud.automl_v1.services.auto_ml.pagers.ListDatasetsAsyncPager | Response message for AutoMl.ListDatasets. Iterating over this object will yield results and resolve additional pages automatically. |
list_model_evaluations
list_model_evaluations(request: Optional[Union[google.cloud.automl_v1.types.service.ListModelEvaluationsRequest, dict]] = None, *, parent: Optional[str] = None, filter: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Lists model evaluations.
from google.cloud import automl_v1
async def sample_list_model_evaluations():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.ListModelEvaluationsRequest(
parent="parent_value",
filter="filter_value",
)
# Make the request
page_result = client.list_model_evaluations(request=request)
# Handle the response
async for response in page_result:
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.ListModelEvaluationsRequest, dict]
The request object. Request message for AutoMl.ListModelEvaluations. |
parent |
`str`
Required. Resource name of the model to list the model evaluations for. If modelId is set as "-", this will list model evaluations from across all models of the parent location. This corresponds to the |
filter |
`str`
Required. An expression for filtering the results of the request. - |
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. |
Type | Description |
google.cloud.automl_v1.services.auto_ml.pagers.ListModelEvaluationsAsyncPager | Response message for AutoMl.ListModelEvaluations. Iterating over this object will yield results and resolve additional pages automatically. |
list_models
list_models(request: Optional[Union[google.cloud.automl_v1.types.service.ListModelsRequest, dict]] = None, *, parent: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Lists models.
from google.cloud import automl_v1
async def sample_list_models():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.ListModelsRequest(
parent="parent_value",
)
# Make the request
page_result = client.list_models(request=request)
# Handle the response
async for response in page_result:
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.ListModelsRequest, dict]
The request object. Request message for AutoMl.ListModels. |
parent |
`str`
Required. Resource name of the project, from which to list the models. This corresponds to the |
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. |
Type | Description |
google.cloud.automl_v1.services.auto_ml.pagers.ListModelsAsyncPager | Response message for AutoMl.ListModels. Iterating over this object will yield results and resolve additional pages automatically. |
model_evaluation_path
model_evaluation_path(
project: str, location: str, model: str, model_evaluation: str
)
Returns a fully-qualified model_evaluation string.
model_path
model_path(project: str, location: str, model: str)
Returns a fully-qualified model string.
parse_annotation_spec_path
parse_annotation_spec_path(path: str)
Parses a annotation_spec path into its component segments.
parse_common_billing_account_path
parse_common_billing_account_path(path: str)
Parse a billing_account path into its component segments.
parse_common_folder_path
parse_common_folder_path(path: str)
Parse a folder path into its component segments.
parse_common_location_path
parse_common_location_path(path: str)
Parse a location path into its component segments.
parse_common_organization_path
parse_common_organization_path(path: str)
Parse a organization path into its component segments.
parse_common_project_path
parse_common_project_path(path: str)
Parse a project path into its component segments.
parse_dataset_path
parse_dataset_path(path: str)
Parses a dataset path into its component segments.
parse_model_evaluation_path
parse_model_evaluation_path(path: str)
Parses a model_evaluation path into its component segments.
parse_model_path
parse_model_path(path: str)
Parses a model path into its component segments.
undeploy_model
undeploy_model(request: Optional[Union[google.cloud.automl_v1.types.service.UndeployModelRequest, dict]] = None, *, name: Optional[str] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Undeploys a model. If the model is not deployed this method has no effect.
Only applicable for Text Classification, Image Object Detection and Tables; all other domains manage deployment automatically.
Returns an empty response in the
response][google.longrunning.Operation.response]
field when it
completes.
from google.cloud import automl_v1
async def sample_undeploy_model():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.UndeployModelRequest(
name="name_value",
)
# Make the request
operation = client.undeploy_model(request=request)
print("Waiting for operation to complete...")
response = await operation.result()
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.UndeployModelRequest, dict]
The request object. Request message for AutoMl.UndeployModel. |
name |
`str`
Required. Resource name of the model to undeploy. This corresponds to the |
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. |
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); } The JSON representation for Empty is empty JSON object {}. |
update_dataset
update_dataset(request: Optional[Union[google.cloud.automl_v1.types.service.UpdateDatasetRequest, dict]] = None, *, dataset: Optional[google.cloud.automl_v1.types.dataset.Dataset] = None, update_mask: Optional[google.protobuf.field_mask_pb2.FieldMask] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Updates a dataset.
from google.cloud import automl_v1
async def sample_update_dataset():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
dataset = automl_v1.Dataset()
dataset.translation_dataset_metadata.source_language_code = "source_language_code_value"
dataset.translation_dataset_metadata.target_language_code = "target_language_code_value"
request = automl_v1.UpdateDatasetRequest(
dataset=dataset,
)
# Make the request
response = await client.update_dataset(request=request)
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.UpdateDatasetRequest, dict]
The request object. Request message for AutoMl.UpdateDataset |
dataset |
Dataset
Required. The dataset which replaces the resource on the server. This corresponds to the |
update_mask |
`google.protobuf.field_mask_pb2.FieldMask`
Required. The update mask applies to the resource. This corresponds to the |
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. |
Type | Description |
google.cloud.automl_v1.types.Dataset | A workspace for solving a single, particular machine learning (ML) problem. A workspace contains examples that may be annotated. |
update_model
update_model(request: Optional[Union[google.cloud.automl_v1.types.service.UpdateModelRequest, dict]] = None, *, model: Optional[google.cloud.automl_v1.types.model.Model] = None, update_mask: Optional[google.protobuf.field_mask_pb2.FieldMask] = None, retry: Union[google.api_core.retry.Retry, google.api_core.gapic_v1.method._MethodDefault] = <_MethodDefault._DEFAULT_VALUE: <object object>>, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = ())
Updates a model.
from google.cloud import automl_v1
async def sample_update_model():
# Create a client
client = automl_v1.AutoMlAsyncClient()
# Initialize request argument(s)
request = automl_v1.UpdateModelRequest(
)
# Make the request
response = await client.update_model(request=request)
# Handle the response
print(response)
Name | Description |
request |
Union[google.cloud.automl_v1.types.UpdateModelRequest, dict]
The request object. Request message for AutoMl.UpdateModel |
model |
Model
Required. The model which replaces the resource on the server. This corresponds to the |
update_mask |
`google.protobuf.field_mask_pb2.FieldMask`
Required. The update mask applies to the resource. This corresponds to the |
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. |
Type | Description |
google.cloud.automl_v1.types.Model | API proto representing a trained machine learning model. |