def test_export_data_exception(self):
# Setup Response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name='operations/test_export_data_exception', done=True)
operation.error.CopyFrom(error)
# Mock the API response
channel = ChannelStub(responses=[operation])
client = automl_v1beta1.AutoMlClient(channel=channel)
# Setup Request
name = client.dataset_path('[PROJECT]', '[LOCATION]', '[DATASET]')
output_config = {}
response = client.export_data(name, output_config)
exception = response.exception()
assert exception.errors[0] == error
def test_model_create_status_delete(capsys):
# create model
client = automl.AutoMlClient()
model_name = "test_" + datetime.datetime.now().strftime("%Y%m%d%H%M%S")
project_location = client.location_path(project_id, compute_region)
my_model = {
"display_name": model_name,
"dataset_id": "3946265060617537378",
"image_classification_model_metadata": {
"train_budget": 24
},
}
response = client.create_model(project_location, my_model)
operation_name = response.operation.name
assert operation_name
# cancel operation
response.cancel()
def create_model(project_id,
compute_region,
dataset_id,
model_name,
user_folder,
train_budget=1):
print("=================================================")
# print("user_folder :", user_folder)
"""Create a model."""
# [START automl_vision_create_model]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_id = 'DATASET_ID_HERE'
# model_name = 'MODEL_NAME_HERE'
# train_budget = integer amount for maximum cost of model
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)
# Set model name and model metadata for the image dataset.
my_model = {
"display_name": model_name,
"dataset_id": dataset_id,
"image_classification_model_metadata": {
"train_budget": train_budget
} if train_budget else {},
}
# Create a model with the model metadata in the region.
response = client.create_model(project_location, my_model)
print("Training operation name: {}".format(response.operation.name))
print("Training started...")
### operation_id_file = os.environ['USER_NAME'] + '/operation_' + project_id + '.txt'
operation_id_file = user_folder + '/operation_' + project_id + '.txt'
with open(operation_id_file, 'w') as f:
f.write(response.operation.name)
def list_models(project_id, compute_region, filter_):
"""List all models."""
# [START automl_vision_list_models]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# filter_ = 'DATASET_ID_HERE'
from google.cloud import automl_v1beta1 as automl
from google.cloud.automl_v1beta1 import enums
client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)
# List all the models available in the region by applying filter.
response = client.list_models(project_location, filter_)
print("List of models:")
for model in response:
# Retrieve deployment state.
if model.deployment_state == enums.Model.DeploymentState.DEPLOYED:
deployment_state = "deployed"
else:
deployment_state = "undeployed"
# Display the model information.
print("Model name: {}".format(model.name))
print("Model id: {}".format(model.name.split("/")[-1]))
print("Model display name: {}".format(model.display_name))
print("Image classification model metadata:")
print("Training budget: {}".format(
model.image_classification_model_metadata.train_budget))
print("Training cost: {}".format(
model.image_classification_model_metadata.train_cost))
print("Stop reason: {}".format(
model.image_classification_model_metadata.stop_reason))
print("Base model id: {}".format(
model.image_classification_model_metadata.base_model_id))
print("Model create time:")
print("\tseconds: {}".format(model.create_time.seconds))
print("\tnanos: {}".format(model.create_time.nanos))
print("Model deployment state: {}".format(deployment_state))
def list_model_evaluations(project_id, compute_region, model_id, filter_):
"""List model evaluations."""
# [START automl_translate_list_model_evaluations]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# filter_ = 'filter expression here'
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)
print("List of model evaluations:")
for element in client.list_model_evaluations(model_full_id, filter_):
print(element)
def create_dataset(project_id, compute_region, dataset_name, multilabel=False):
"""Create a dataset."""
# [START automl_language_create_dataset]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_name = 'DATASET_NAME_HERE'
# multilabel = True for multilabel or False for multiclass
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)
# Classification type is assigned based on multilabel value.
classification_type = "MULTICLASS"
if multilabel:
classification_type = "MULTILABEL"
# Specify the text classification type for the dataset.
dataset_metadata = {"classification_type": classification_type}
# Set dataset name and metadata.
my_dataset = {
"display_name": dataset_name,
"text_classification_dataset_metadata": dataset_metadata,
}
# Create a dataset with the dataset metadata in the region.
dataset = client.create_dataset(project_location, my_dataset)
# Display the dataset information.
print("Dataset name: {}".format(dataset.name))
print("Dataset id: {}".format(dataset.name.split("/")[-1]))
print("Dataset display name: {}".format(dataset.display_name))
print("Text classification dataset metadata:")
print("\t{}".format(dataset.text_classification_dataset_metadata))
print("Dataset example count: {}".format(dataset.example_count))
print("Dataset create time:")
print("\tseconds: {}".format(dataset.create_time.seconds))
print("\tnanos: {}".format(dataset.create_time.nanos))
def undeploy_model(project_id, compute_region, model_id):
"""
Undeploy model.
# project_id: the 'Project ID showed in GCP Console
# compute_region: only 'us-central1' works now
# model_id: 'table id+today's day'
"""
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)
# Deploy model
response = client.undeploy_model(model_full_id)
print("Model undeployed.")
def import_dataset(
project_id="YOUR_PROJECT_ID",
dataset_id="YOUR_DATASET_ID",
path="gs://YOUR_BUCKET_ID/path/to/data.csv",
):
"""Import a dataset."""
client = automl.AutoMlClient()
# Get the full path of the dataset.
dataset_full_id = client.dataset_path(project_id, "us-central1",
dataset_id)
# Get the multiple Google Cloud Storage URIs
input_uris = path.split(",")
gcs_source = automl.types.GcsSource(input_uris=input_uris)
input_config = automl.types.InputConfig(gcs_source=gcs_source)
# Import data from the input URI
response = client.import_data(dataset_full_id, input_config)
print("Processing import...")
print("Data imported. {}".format(response.result()))
def predict(image):
project_id = 'qualiscan-216706'
compute_region = 'us-central1'
model_id = 'ICN2956512205565128229'
score_threshold = '0.5'
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(
project_id, compute_region, model_id
)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
img_data = b64decode(image)
filename = 'some_image.jpg' # I assume you have a way of picking unique filenames
with open(filename, 'wb') as f:
f.write(img_data)
# Read the image and assign to payload.
with open(filename, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
results = []
for result in response.payload:
print(result)
results.append({"display_name": result.display_name,
"classification_score": result.classification.score})
# print("Predicted class name: {}".format(result.display_name))
# print("Predicted class score: {}".format(result.classification.score))
# print(response)
return results
def __init__(self,ctx):
super(GoogleA2ML, self).__init__()
self.ctx = ctx
self.client = automl.AutoMlClient()
self.name = ctx.config['config'].get('name',None)
self.project_id = ctx.config['google'].get('project',None)
self.compute_region = ctx.config['google'].get('cluster/region','us-central1')
self.metric = ctx.config['google'].get('experiment/metric',"MINIMIZE_MAE")
self.project_location = self.client.location_path(self.project_id,self.compute_region)
self.dataset_id = ctx.config['google'].get('dataset_id',None)
self.dataset_name = ctx.config['google'].get('dataset_name',None)
self.source = ctx.config['config'].get('source', None)
self.dataset_name = self.client.dataset_path(self.project_id, self.compute_region, self.dataset_id)
self.target = ctx.config['config'].get('target',None)
self.exclude = ctx.config['config'].get('exclude',None)
self.budget = ctx.config['config'].get('budget',None)
self.operation_name = ctx.config['google'].get('operation_name',None)
self.model_name = ctx.config['google'].get('model_name',None)
self.gsbucket = ctx.config['google'].get('gsbucket','gs://a2ml')
def create_dataset(project_id="YOUR_PROJECT_ID",
display_name="your_datasets_display_name"):
"""Create a automl video object tracking dataset."""
client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
project_location = f"projects/{project_id}/locations/us-central1"
metadata = automl.VideoObjectTrackingDatasetMetadata()
dataset = automl.Dataset(
display_name=display_name,
video_object_tracking_dataset_metadata=metadata,
)
# Create a dataset with the dataset metadata in the region.
created_dataset = client.create_dataset(parent=project_location,
dataset=dataset)
# Display the dataset information
print("Dataset name: {}".format(created_dataset.name))
print("Dataset id: {}".format(created_dataset.name.split("/")[-1]))
def create_dataset(project_id, compute_region, dataset_name, source, target):
"""Create a dataset."""
# [START automl_translation_create_dataset]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_name = 'DATASET_NAME_HERE'
# source = 'LANGUAGE_CODE_OF_SOURCE_LANGUAGE'
# target = 'LANGUAGE_CODE_OF_TARGET_LANGUAGE'
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)
# Specify the source and target language.
dataset_metadata = {
"source_language_code": source,
"target_language_code": target,
}
# Set dataset name and dataset metadata
my_dataset = {
"display_name": dataset_name,
"translation_dataset_metadata": dataset_metadata,
}
# Create a dataset with the dataset metadata in the region.
dataset = client.create_dataset(project_location, my_dataset)
# Display the dataset information
print("Dataset name: {}".format(dataset.name))
print("Dataset id: {}".format(dataset.name.split("/")[-1]))
print("Dataset display name: {}".format(dataset.display_name))
print("Translation dataset Metadata:")
print("\tsource_language_code: {}".format(
dataset.translation_dataset_metadata.source_language_code))
print("\ttarget_language_code: {}".format(
dataset.translation_dataset_metadata.target_language_code))
print("Dataset create time:")
print("\tseconds: {}".format(dataset.create_time.seconds))
print("\tnanos: {}".format(dataset.create_time.nanos))
def predict(project_id,
compute_region,
model_id,
file_path,
score_threshold=""):
"""Make a prediction for an image."""
# [START automl_vision_predict]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# file_path = '/local/path/to/file'
# score_threshold = 'value from 0.0 to 0.5'
from google.cloud import automl_v1beta1 as automl
automl_client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = automl_client.model_path(project_id, compute_region,
model_id)
# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()
# Read the image and assign to payload.
with open(file_path, "rb") as image_file:
content = image_file.read()
payload = {"image": {"image_bytes": content}}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
params = {"score_threshold": score_threshold}
response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
for result in response.payload:
print("Predicted class name: {}".format(result.display_name))
print("Predicted class score: {}".format(result.classification.score))
def list_models(project_id, compute_region, filter_=None):
"""
List all models.
# project_id: the 'Project ID showed in GCP Console
# compute_region: only 'us-central1' works now
"""
from google.cloud import automl_v1beta1 as automl
from google.cloud.automl_v1beta1 import enums
client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)
# List all the models available in the region by applying filter.
response = client.list_models(project_location, filter_)
print("List of models:")
for model in response:
# Retrieve deployment state.
if model.deployment_state == enums.Model.DeploymentState.DEPLOYED:
deployment_state = "deployed"
else:
deployment_state = "undeployed"
# Display the model information.
print("Model name: {}".format(model.name))
print("Model id: {}".format(model.name.split("/")[-1]))
print("Model display name: {}".format(model.display_name))
metadata = model.tables_model_metadata
print("Target column display name: {}".format(
metadata.target_column_spec.display_name))
print("Training budget in node milli hours: {}".format(
metadata.train_budget_milli_node_hours))
print("Training cost in node milli hours: {}".format(
metadata.train_cost_milli_node_hours))
print("Model create time:")
print("\tseconds: {}".format(model.create_time.seconds))
print("\tnanos: {}".format(model.create_time.nanos))
print("Model deployment state: {}".format(deployment_state))
print("\n")
def get_model(project_id, compute_region, model_id):
"""Get model details."""
# [START automl_vision_get_model]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
from google.cloud import automl_v1beta1 as automl
from google.cloud.automl_v1beta1 import enums
client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)
# Get complete detail of the model.
model = client.get_model(model_full_id)
# Retrieve deployment state.
if model.deployment_state == enums.Model.DeploymentState.DEPLOYED:
deployment_state = "deployed"
else:
deployment_state = "undeployed"
# Display the model information.
print("Model name: {}".format(model.name))
print("Model id: {}".format(model.name.split("/")[-1]))
print("Model display name: {}".format(model.display_name))
print("Image classification model metadata:")
print("Training budget: {}".format(
model.image_classification_model_metadata.train_budget))
print("Training cost: {}".format(
model.image_classification_model_metadata.train_cost))
print("Stop reason: {}".format(
model.image_classification_model_metadata.stop_reason))
print("Base model id: {}".format(
model.image_classification_model_metadata.base_model_id))
print("Model create time:")
print("\tseconds: {}".format(model.create_time.seconds))
print("\tnanos: {}".format(model.create_time.nanos))
print("Model deployment state: {}".format(deployment_state))
def update_column_spec(project_id,
compute_region,
dataset_id,
table_spec_id,
column_spec_id,
type_code,
nullable=None):
"""
Update column spec.
# project_id: the 'Project ID showed in GCP Console
# compute_region: only 'us-central1' works now
# dataset_id: start with 'TBL', can retrieve the info by execute list_datasets
# table_spec_id: a long format numeric id, can retrieve by executing list_table_specs
# column_spec_id: a long format numeric id, can retrieve by executing get_table_specs
# type_code: Numeric or Category
"""
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# Get the full path of the column spec.
column_spec_full_id = client.column_spec_path(project_id, compute_region,
dataset_id, table_spec_id,
column_spec_id)
# Set type code and nullable in data_type.
data_type = {'type_code': type_code}
if nullable is not None:
data_type['nullable'] = nullable
# Set the updated data_type in the column_spec.
my_column_spec = {
'name': column_spec_full_id,
'data_type': data_type,
}
# Update the column spec.
response = client.update_column_spec(my_column_spec)
# synchronous check of operation status.
print("Table spec updated. {}".format(response))
def test_undeploy_model_exception(self):
# Setup Response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name="operations/test_undeploy_model_exception", done=True)
operation.error.CopyFrom(error)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch("google.api_core.grpc_helpers.create_channel")
with patch as create_channel:
create_channel.return_value = channel
client = automl_v1beta1.AutoMlClient()
# Setup Request
name = client.model_path("[PROJECT]", "[LOCATION]", "[MODEL]")
response = client.undeploy_model(name)
exception = response.exception()
assert exception.errors[0] == error
def delete_model(project_id, compute_region, model_id):
"""Delete a model."""
# [START automl_translate_delete_model]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)
# Delete a model.
response = client.delete_model(name=model_full_id)
# synchronous check of operation status.
print("Model deleted. {}".format(response.result()))
def delete_model(project_id, compute_region, model_id):
"""Deletes a model."""
# [START automl_vision_iod_delete_model]
## To do: Uncomment and set the following variables
# project_id = '[PROJECT_ID]'
# compute_region = '[COMPUTE_REGION]'
# model_id = '[MODEL_ID]'
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)
# Delete a model.
response = client.delete_model(model_full_id)
# synchronous check of operation status.
print('Model deleted. {}'.format(response.result()))
def sample_create_dataset():
"""Create Dataset"""
client = automl_v1beta1.AutoMlClient()
parent = client.location_path('hzyi-186423', 'us-central1')
display_name = 'my_dataset'
source_language_code = 'en-GB'
target_language_code = 'fr-CA'
translation_dataset_metadata = {
'source_language_code': source_language_code,
'target_language_code': target_language_code
}
dataset = {
'display_name': display_name,
'translation_dataset_metadata': translation_dataset_metadata
}
response = client.create_dataset(parent, dataset)
print(u'Dataset name: {}'.format(response.name))
def test_delete_dataset_exception(self):
# Setup Response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name='operations/test_delete_dataset_exception', done=True)
operation.error.CopyFrom(error)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch('google.api_core.grpc_helpers.create_channel')
with patch as create_channel:
create_channel.return_value = channel
client = automl_v1beta1.AutoMlClient()
# Setup Request
name = client.dataset_path('[PROJECT]', '[LOCATION]', '[DATASET]')
response = client.delete_dataset(name)
exception = response.exception()
assert exception.errors[0] == error
def display_evaluation(project_id, compute_region, model_id, filter_=None):
"""
Display evaluation.
# project_id: the 'Project ID showed in GCP Console
# compute_region: only 'us-central1' works now
# model_id: 'table id+today's day'
"""
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)
# List all the model evaluations in the model by applying filter.
response = client.list_model_evaluations(model_full_id, filter_)
# Iterate through the results.
for evaluation in response:
# There is evaluation for each class in a model and for overall model.
# Get only the evaluation of overall model.
if not evaluation.annotation_spec_id:
model_evaluation_id = evaluation.name.split("/")[-1]
# Resource name for the model evaluation.
model_evaluation_full_id = client.model_evaluation_path(
project_id, compute_region, model_id, model_evaluation_id)
# Get a model evaluation.
model_evaluation = client.get_model_evaluation(model_evaluation_full_id)
regression_metrics = model_evaluation.regression_evaluation_metrics
if str(regression_metrics):
print("Model regression metrics:")
print("Model RMSE: {}".format(
regression_metrics.root_mean_squared_error))
print("Model MAE: {}".format(regression_metrics.mean_absolute_error))
print("Model MAPE: {}".format(
regression_metrics.mean_absolute_percentage_error))
print("Model R^2: {}".format(regression_metrics.r_squared))
def test_export_data_exception(self):
# Setup Response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name="operations/test_export_data_exception", done=True)
operation.error.CopyFrom(error)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch("google.api_core.grpc_helpers.create_channel")
with patch as create_channel:
create_channel.return_value = channel
client = automl_v1beta1.AutoMlClient()
# Setup Request
name = client.dataset_path("[PROJECT]", "[LOCATION]", "[DATASET]")
output_config = {}
response = client.export_data(name, output_config)
exception = response.exception()
assert exception.errors[0] == error
def create_dataset(project_id, compute_region, dataset_metadata, path):
"""Create dataset and import data."""
client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
parent = client.location_path(project_id, compute_region)
# Create a dataset with the dataset metadata in the region.
dataset = client.create_dataset(parent, dataset_metadata)
# Import data from the input URI.
response = client.import_data(dataset.name, {
"gcs_source": {
"input_uris": [path]
}
})
print("Processing import...")
print(f"Data imported. {response.result()}")
def test_model_create_status_delete(capsys):
# create model
client = automl.AutoMlClient()
model_name = "test_" + datetime.datetime.now().strftime("%Y%m%d%H%M%S")
project_location = client.location_path(project_id, compute_region)
my_model = {
"display_name": model_name,
"dataset_id": "3876092572857648864",
"translation_model_metadata": {"base_model": ""},
}
response = client.create_model(project_location, my_model)
operation_name = response.operation.name
assert operation_name
# get operation status
automl_translation_model.get_operation_status(operation_name)
out, _ = capsys.readouterr()
assert "Operation status: " in out
# cancel operation
response.cancel()
def delete_dataset(project_id, compute_region, dataset_id):
"""Delete a dataset"""
# [START automl_vision_delete_dataset]
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_id = 'DATASET_ID_HERE'
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# Get the full path of the dataset.
dataset_full_id = client.dataset_path(project_id, compute_region,
dataset_id)
# Delete a dataset.
response = client.delete_dataset(dataset_full_id)
# synchronous check of operation status.
print("Dataset deleted. {}".format(response.result()))
def delete_dataset(project_id, compute_region, dataset_id):
"""
Delete a dataset.
# project_id: the 'Project ID showed in GCP Console
# compute_region: only 'us-central1' works now
# dataset_id: start with 'TBL', can retrieve the info by execute list_datasets
"""
from google.cloud import automl_v1beta1 as automl
client = automl.AutoMlClient()
# Get the full path of the dataset.
dataset_full_id = client.dataset_path(project_id, compute_region,
dataset_id)
# Delete a dataset.
response = client.delete_dataset(dataset_full_id)
# synchronous check of operation status.
print("Dataset deleted. {}".format(response.result()))
def test_model_create_status_delete(capsys):
# create model
client = automl.AutoMlClient()
model_name = "test_" + datetime.datetime.now().strftime("%Y%m%d%H%M%S")
project_location = client.location_path(project_id, compute_region)
my_model = {
"display_name": model_name,
"dataset_id": "2551826603472450019",
"text_classification_model_metadata": {},
}
response = client.create_model(project_location, my_model)
operation_name = response.operation.name
assert operation_name
# get operation status
automl_natural_language_model.get_operation_status(operation_name)
out, _ = capsys.readouterr()
assert "Operation status: " in out
# cancel operation
response.cancel()
def test_undeploy_model(self):
# Setup Expected Response
name_2 = 'name2-1052831874'
done = True
expected_response = {'name': name_2, 'done': done}
expected_response = operations_pb2.Operation(**expected_response)
# Mock the API response
channel = ChannelStub(responses=[expected_response])
client = automl_v1beta1.AutoMlClient(channel=channel)
# Setup Request
name = client.model_path('[PROJECT]', '[LOCATION]', '[MODEL]')
response = client.undeploy_model(name)
assert expected_response == response
assert len(channel.requests) == 1
expected_request = service_pb2.UndeployModelRequest(name=name)
actual_request = channel.requests[0][1]
assert expected_request == actual_request
def sample_cancel_operation(project, operation_id):
"""
Cancel Long-Running Operation
Args:
project Required. Your Google Cloud Project ID.
operation_id Required. The ID of the Operation.
"""
client = automl_v1beta1.AutoMlClient()
operations_client = client._transport.operations_client
# project = '[Google Cloud Project ID]'
# operation_id = '[Operation ID]'
name = "projects/{}/locations/us-central1/operations/{}".format(
project, operation_id)
operations_client.cancel_operation(name)
print(u"Cancelled operation: {}".format(name))
