From 50e4e9ab08452fcf5fa233823d9e73c9fbd736af Mon Sep 17 00:00:00 2001 From: rudrakhsha Date: Fri, 11 Apr 2025 12:34:45 +0000 Subject: [PATCH 1/6] Added code samples to update model armor templates --- .../main/java/modelarmor/UpdateTemplate.java | 81 +++++++++++++ .../java/modelarmor/UpdateTemplateLabels.java | 65 ++++++++++ .../modelarmor/UpdateTemplateMetadata.java | 85 +++++++++++++ .../UpdateTemplateWithMaskConfiguration.java | 84 +++++++++++++ .../src/test/java/modelarmor/SnippetsIT.java | 113 ++++++++++++++++++ 5 files changed, 428 insertions(+) create mode 100644 modelarmor/src/main/java/modelarmor/UpdateTemplate.java create mode 100644 modelarmor/src/main/java/modelarmor/UpdateTemplateLabels.java create mode 100644 modelarmor/src/main/java/modelarmor/UpdateTemplateMetadata.java create mode 100644 modelarmor/src/main/java/modelarmor/UpdateTemplateWithMaskConfiguration.java create mode 100644 modelarmor/src/test/java/modelarmor/SnippetsIT.java diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplate.java b/modelarmor/src/main/java/modelarmor/UpdateTemplate.java new file mode 100644 index 00000000000..64d5eb06e45 --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplate.java @@ -0,0 +1,81 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package modelarmor; + +import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; +import com.google.cloud.modelarmor.v1.FilterConfig; +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter; +import com.google.cloud.modelarmor.v1.RaiFilterType; +import com.google.cloud.modelarmor.v1.Template; +import com.google.cloud.modelarmor.v1.TemplateName; +import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; +import com.google.protobuf.FieldMask; +import com.google.protobuf.util.JsonFormat; +import java.util.List; + +public class UpdateTemplate { + + public static void main(String[] args) throws Exception { + // TODO(developer): Replace these variables before running the sample. + String projectId = "your-project-id"; + String locationId = "your-location-id"; + String templateId = "your-template-id"; + + updateTemplate(projectId, locationId, templateId); + } + + public static void updateTemplate(String projectId, String locationId, String templateId) + throws Exception { + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + ModelArmorSettings modelArmorSettings = + ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint).build(); + + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + String name = TemplateName.of(projectId, locationId, templateId).toString(); + + Template template = + Template.newBuilder() + .setName(name) + .setFilterConfig( + FilterConfig.newBuilder() + .setRaiSettings( + RaiFilterSettings.newBuilder() + .addAllRaiFilters( + List.of( + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HARASSMENT) + .setConfidenceLevel( + DetectionConfidenceLevel.MEDIUM_AND_ABOVE) + .build())) + .build()) + .build()) + .build(); + + UpdateTemplateRequest request = + UpdateTemplateRequest.newBuilder() + .setTemplate(template) + .setUpdateMask(FieldMask.newBuilder().addPaths("filter_config").build()) + .build(); + + Template updatedTemplate = client.updateTemplate(request); + System.out.println("Updated template: " + JsonFormat.printer().print(updatedTemplate)); + } + } +} diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateLabels.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateLabels.java new file mode 100644 index 00000000000..c07c8c5c470 --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplateLabels.java @@ -0,0 +1,65 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package modelarmor; + +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.Template; +import com.google.cloud.modelarmor.v1.TemplateName; +import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; +import com.google.protobuf.FieldMask; +import com.google.protobuf.util.JsonFormat; +import java.util.HashMap; +import java.util.Map; + +public class UpdateTemplateLabels { + + public static void main(String[] args) throws Exception { + // TODO(developer): Replace these variables before running the sample. + String projectId = "your-project-id"; + String locationId = "your-location-id"; + String templateId = "your-template-id"; + + updateTemplateLabels(projectId, locationId, templateId); + } + + public static void updateTemplateLabels(String projectId, String locationId, String templateId) + throws Exception { + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + ModelArmorSettings modelArmorSettings = + ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint).build(); + + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + String name = TemplateName.of(projectId, locationId, templateId).toString(); + + Map labels = new HashMap<>(); + labels.put("key3", "value3"); + labels.put("key4", "value4"); + + Template template = Template.newBuilder().setName(name).putAllLabels(labels).build(); + + UpdateTemplateRequest request = + UpdateTemplateRequest.newBuilder() + .setTemplate(template) + .setUpdateMask(FieldMask.newBuilder().addPaths("labels").build()) + .build(); + + Template updatedTemplate = client.updateTemplate(request); + System.out.println("Updated template labels: " + JsonFormat.printer().print(updatedTemplate)); + } + } +} diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateMetadata.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateMetadata.java new file mode 100644 index 00000000000..bfbea5522a0 --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplateMetadata.java @@ -0,0 +1,85 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package modelarmor; + +import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; +import com.google.cloud.modelarmor.v1.FilterConfig; +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter; +import com.google.cloud.modelarmor.v1.RaiFilterType; +import com.google.cloud.modelarmor.v1.Template; +import com.google.cloud.modelarmor.v1.TemplateName; +import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; +import com.google.protobuf.util.JsonFormat; +import java.util.List; + +public class UpdateTemplateMetadata { + + public static void main(String[] args) throws Exception { + // TODO(developer): Replace these variables before running the sample. + String projectId = "your-project-id"; + String locationId = "your-location-id"; + String templateId = "your-template-id"; + + updateTemplateMetadata(projectId, locationId, templateId); + } + + public static void updateTemplateMetadata(String projectId, String locationId, String templateId) + throws Exception { + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + ModelArmorSettings modelArmorSettings = + ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint).build(); + + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + String name = TemplateName.of(projectId, locationId, templateId).toString(); + + Template template = + Template.newBuilder() + .setName(name) + // Ensure the rest of the template is correctly populated as needed. + .setTemplateMetadata( + Template.TemplateMetadata.newBuilder() + .setIgnorePartialInvocationFailures(true) + .setLogSanitizeOperations(true)) + .setFilterConfig( + FilterConfig.newBuilder() + .setRaiSettings( + RaiFilterSettings.newBuilder() + .addAllRaiFilters( + List.of( + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.DANGEROUS) + .setConfidenceLevel(DetectionConfidenceLevel.HIGH) + .build())) + .build()) + .build()) + .build(); + + UpdateTemplateRequest request = + UpdateTemplateRequest.newBuilder() + .setTemplate(template) + // Removed the setUpdateMask line to attempt a full update. + .build(); + + Template updatedTemplate = client.updateTemplate(request); + System.out.println( + "Updated template metadata: " + JsonFormat.printer().print(updatedTemplate)); + } + } +} diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMaskConfiguration.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMaskConfiguration.java new file mode 100644 index 00000000000..39375e9542e --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMaskConfiguration.java @@ -0,0 +1,84 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package modelarmor; + +import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; +import com.google.cloud.modelarmor.v1.FilterConfig; +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter; +import com.google.cloud.modelarmor.v1.RaiFilterType; +import com.google.cloud.modelarmor.v1.Template; +import com.google.cloud.modelarmor.v1.TemplateName; +import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; +import com.google.protobuf.FieldMask; +import com.google.protobuf.util.JsonFormat; +import java.util.List; + +public class UpdateTemplateWithMaskConfiguration { + + public static void main(String[] args) throws Exception { + // TODO(developer): Replace these variables before running the sample. + String projectId = "your-project-id"; + String locationId = "your-location-id"; + String templateId = "your-template-id"; + + updateTemplateWithMaskConfiguration(projectId, locationId, templateId); + } + + public static void updateTemplateWithMaskConfiguration( + String projectId, String locationId, String templateId) throws Exception { + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + ModelArmorSettings modelArmorSettings = + ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint).build(); + + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + String name = TemplateName.of(projectId, locationId, templateId).toString(); + + Template template = + Template.newBuilder() + .setName(name) + .setFilterConfig( + FilterConfig.newBuilder() + .setRaiSettings( + RaiFilterSettings.newBuilder() + .addAllRaiFilters( + List.of( + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HARASSMENT) + .setConfidenceLevel( + DetectionConfidenceLevel.MEDIUM_AND_ABOVE) + .build())) + .build()) + .build()) + .build(); + + UpdateTemplateRequest request = + UpdateTemplateRequest.newBuilder() + .setTemplate(template) + .setUpdateMask( + FieldMask.newBuilder().addPaths("filter_config.rai_settings.rai_filters").build()) + .build(); + + Template updatedTemplate = client.updateTemplate(request); + System.out.println( + "Updated template with mask configuration: " + + JsonFormat.printer().print(updatedTemplate)); + } + } +} diff --git a/modelarmor/src/test/java/modelarmor/SnippetsIT.java b/modelarmor/src/test/java/modelarmor/SnippetsIT.java new file mode 100644 index 00000000000..9461ec74bc8 --- /dev/null +++ b/modelarmor/src/test/java/modelarmor/SnippetsIT.java @@ -0,0 +1,113 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package modelarmor; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.cloud.modelarmor.v1.Template; +import com.google.common.base.Strings; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.util.UUID; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** Integration (system) tests for {@link Snippets}. */ +@RunWith(JUnit4.class) +@SuppressWarnings("checkstyle:AbbreviationAsWordInName") +public class SnippetsIT { + + private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); + private static final String LOCATION = "us-central1"; + private static final String MA_REGIONAL_ENDPOINT = + String.format("modelarmor.%s.rep.googleapis.com:443", LOCATION); + private static final String DLP_REGIONAL_ENDPOINT = + String.format("dlp.%s.rep.googleapis.com:443", LOCATION); + private static final String INSPECT_TEMPLATE_ID = + "model-armour-inspect-template-" + UUID.randomUUID().toString(); + private static final String DEIDENTIFY_TEMPLATE_ID = + "model-armour-deidentify-template-" + UUID.randomUUID().toString(); + private static Template TEST_MODELARMOR_TEMPLATE; + private static Template TEST_MODELARMOR_TEMPLATE_NAME; + private static String TEMPLATE_ID; + + private ByteArrayOutputStream stdOut; + + @BeforeClass + public static void beforeAll() throws Exception { + Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT", Strings.isNullOrEmpty(PROJECT_ID)); + Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT_LOCATION", Strings.isNullOrEmpty(LOCATION)); + } + + @AfterClass + public static void afterAll() throws Exception { + Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT", Strings.isNullOrEmpty(PROJECT_ID)); + } + + @Before + public void beforeEach() { + stdOut = new ByteArrayOutputStream(); + System.setOut(new PrintStream(stdOut)); + + TEMPLATE_ID = "test-model-armor-" + UUID.randomUUID().toString(); + } + + @After + public void afterEach() throws Exception { + stdOut = null; + System.setOut(null); + } + + @Test + public void testUpdateModelArmorTemplate() throws Exception { + CreateTemplate.createTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + UpdateTemplate.updateTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + assertThat(stdOut.toString()).contains("Updated template"); + DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + } + + @Test + public void testUpdateModelArmorTemplateWithLabels() throws Exception { + CreateTemplate.createTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + UpdateTemplateLabels.updateTemplateLabels(PROJECT_ID, LOCATION, TEMPLATE_ID); + assertThat(stdOut.toString()).contains("Updated template labels"); + DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + } + + @Test + public void testUpdateModelArmorTemplateWithMetadata() throws Exception { + CreateTemplate.createTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + UpdateTemplateMetadata.updateTemplateMetadata(PROJECT_ID, LOCATION, TEMPLATE_ID); + assertThat(stdOut.toString()).contains("Updated template metadata"); + DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + } + + @Test + public void testUpdateModelArmorTemplateWithMaskConfiguration() throws Exception { + CreateTemplate.createTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + UpdateTemplateWithMaskConfiguration.updateTemplateWithMaskConfiguration( + PROJECT_ID, LOCATION, TEMPLATE_ID); + assertThat(stdOut.toString()).contains("Updated template with mask configuration"); + DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + } +} From 16c2f73296139e9bbe8d95235a58efbafffcebfd Mon Sep 17 00:00:00 2001 From: Harsh Nasit Date: Tue, 15 Apr 2025 22:24:16 +0530 Subject: [PATCH 2/6] address-review-comments --- modelarmor/pom.xml | 84 +++++++++++++ .../main/java/modelarmor/CreateTemplate.java | 111 ++++++++++++++++ .../modelarmor/CreateTemplateWithLabels.java | 115 +++++++++++++++++ .../CreateTemplateWithMetadata.java | 118 ++++++++++++++++++ .../main/java/modelarmor/DeleteTemplate.java | 57 +++++++++ .../main/java/modelarmor/UpdateTemplate.java | 93 +++++++++----- .../modelarmor/UpdateTemplateMetadata.java | 85 ------------- ...els.java => UpdateTemplateWithLabels.java} | 55 +++++--- .../UpdateTemplateWithMaskConfiguration.java | 84 ------------- .../UpdateTemplateWithMetadata.java | 92 ++++++++++++++ .../src/test/java/modelarmor/SnippetsIT.java | 102 ++++++++------- 11 files changed, 740 insertions(+), 256 deletions(-) create mode 100644 modelarmor/pom.xml create mode 100644 modelarmor/src/main/java/modelarmor/CreateTemplate.java create mode 100644 modelarmor/src/main/java/modelarmor/CreateTemplateWithLabels.java create mode 100644 modelarmor/src/main/java/modelarmor/CreateTemplateWithMetadata.java create mode 100644 modelarmor/src/main/java/modelarmor/DeleteTemplate.java delete mode 100644 modelarmor/src/main/java/modelarmor/UpdateTemplateMetadata.java rename modelarmor/src/main/java/modelarmor/{UpdateTemplateLabels.java => UpdateTemplateWithLabels.java} (52%) delete mode 100644 modelarmor/src/main/java/modelarmor/UpdateTemplateWithMaskConfiguration.java create mode 100644 modelarmor/src/main/java/modelarmor/UpdateTemplateWithMetadata.java diff --git a/modelarmor/pom.xml b/modelarmor/pom.xml new file mode 100644 index 00000000000..ee0c4f24516 --- /dev/null +++ b/modelarmor/pom.xml @@ -0,0 +1,84 @@ + + + + 4.0.0 + com.example.modelarmor + modelarmor-samples + jar + + + + com.google.cloud.samples + shared-configuration + 1.2.0 + + + + UTF-8 + 11 + 11 + + + + + + com.google.cloud + libraries-bom + 26.59.0 + pom + import + + + + + + + com.google.cloud + google-cloud-modelarmor + + + + com.google.cloud + google-cloud-dlp + + + + com.google.protobuf + protobuf-java-util + + + + + junit + junit + 4.13.2 + test + + + com.google.truth + truth + 1.4.0 + test + + + + diff --git a/modelarmor/src/main/java/modelarmor/CreateTemplate.java b/modelarmor/src/main/java/modelarmor/CreateTemplate.java new file mode 100644 index 00000000000..79227001db0 --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/CreateTemplate.java @@ -0,0 +1,111 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ + +package modelarmor; + +// [START modelarmor_create_template] + +import com.google.cloud.modelarmor.v1.CreateTemplateRequest; +import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; +import com.google.cloud.modelarmor.v1.FilterConfig; +import com.google.cloud.modelarmor.v1.LocationName; +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter; +import com.google.cloud.modelarmor.v1.RaiFilterType; +import com.google.cloud.modelarmor.v1.Template; +import java.io.IOException; +import java.util.List; + +public class CreateTemplate { + + public static void main(String[] args) throws IOException { + // TODO(developer): Replace these variables before running the sample. + + // Specify the Google Project ID. + String projectId = "your-project-id"; + // Specify the location ID. For example, us-central1. + String locationId = "your-location-id"; + // Specify the template ID. + String templateId = "your-template-id"; + + createTemplate(projectId, locationId, templateId); + } + + public static Template createTemplate(String projectId, String locationId, String templateId) + throws IOException { + // Construct the API endpoint URL. + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint) + .build(); + + // Initialize the client that will be used to send requests. This client + // only needs to be created once, and can be reused for multiple requests. + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + String parent = LocationName.of(projectId, locationId).toString(); + + // Build the Model Armor template with your preferred filters. + // For more details on filters, please refer to the following doc: + // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters + + // Configure Responsible AI filter with multiple categories and their confidence + // levels. + RaiFilterSettings raiFilterSettings = + RaiFilterSettings.newBuilder() + .addAllRaiFilters( + List.of( + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.DANGEROUS) + .setConfidenceLevel(DetectionConfidenceLevel.HIGH) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HATE_SPEECH) + .setConfidenceLevel(DetectionConfidenceLevel.HIGH) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT) + .setConfidenceLevel(DetectionConfidenceLevel.LOW_AND_ABOVE) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HARASSMENT) + .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE) + .build())) + .build(); + + FilterConfig modelArmorFilter = FilterConfig.newBuilder() + .setRaiSettings(raiFilterSettings) + .build(); + + Template template = Template.newBuilder() + .setFilterConfig(modelArmorFilter) + .build(); + + CreateTemplateRequest request = CreateTemplateRequest.newBuilder() + .setParent(parent) + .setTemplateId(templateId) + .setTemplate(template) + .build(); + + Template createdTemplate = client.createTemplate(request); + System.out.println("Created template: " + createdTemplate.getName()); + + return createdTemplate; + } + } +} + +// [END modelarmor_create_template] diff --git a/modelarmor/src/main/java/modelarmor/CreateTemplateWithLabels.java b/modelarmor/src/main/java/modelarmor/CreateTemplateWithLabels.java new file mode 100644 index 00000000000..101d273d2e5 --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/CreateTemplateWithLabels.java @@ -0,0 +1,115 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ + +package modelarmor; + +// [START modelarmor_create_template_with_labels] + +import com.google.cloud.modelarmor.v1.CreateTemplateRequest; +import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; +import com.google.cloud.modelarmor.v1.FilterConfig; +import com.google.cloud.modelarmor.v1.LocationName; +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter; +import com.google.cloud.modelarmor.v1.RaiFilterType; +import com.google.cloud.modelarmor.v1.Template; +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class CreateTemplateWithLabels { + + public static void main(String[] args) throws IOException { + // TODO(developer): Replace these variables before running the sample. + + // Specify the Google Project ID. + String projectId = "your-project-id"; + // Specify the location ID. For example, us-central1. + String locationId = "your-location-id"; + // Specify the template ID. + String templateId = "your-template-id"; + + createTemplateWithLabels(projectId, locationId, templateId); + } + + public static Template createTemplateWithLabels( + String projectId, String locationId, String templateId) throws IOException { + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint) + .build(); + + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + String parent = LocationName.of(projectId, locationId).toString(); + + // Build the Model Armor template with your preferred filters. + // For more details on filters, please refer to the following doc: + // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters + + // Configure Responsible AI filter with multiple categories and their confidence + // levels. + RaiFilterSettings raiFilterSettings = + RaiFilterSettings.newBuilder() + .addAllRaiFilters( + List.of( + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.DANGEROUS) + .setConfidenceLevel(DetectionConfidenceLevel.HIGH) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HATE_SPEECH) + .setConfidenceLevel(DetectionConfidenceLevel.HIGH) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT) + .setConfidenceLevel(DetectionConfidenceLevel.LOW_AND_ABOVE) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HARASSMENT) + .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE) + .build())) + .build(); + + FilterConfig modelArmorFilter = FilterConfig.newBuilder() + .setRaiSettings(raiFilterSettings) + .build(); + + // Create Labels. + Map labels = new HashMap<>(); + labels.put("key1", "value1"); + labels.put("key2", "value2"); + + Template template = Template.newBuilder() + .setFilterConfig(modelArmorFilter) + .putAllLabels(labels) + .build(); + + CreateTemplateRequest request = CreateTemplateRequest.newBuilder() + .setParent(parent) + .setTemplateId(templateId) + .setTemplate(template) + .build(); + + Template createdTemplate = client.createTemplate(request); + System.out.println("Created template with labels: " + createdTemplate.getName()); + + return createdTemplate; + } + } +} +// [END modelarmor_create_template_with_labels] diff --git a/modelarmor/src/main/java/modelarmor/CreateTemplateWithMetadata.java b/modelarmor/src/main/java/modelarmor/CreateTemplateWithMetadata.java new file mode 100644 index 00000000000..00bfef06543 --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/CreateTemplateWithMetadata.java @@ -0,0 +1,118 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ + +package modelarmor; + +// [START modelarmor_create_template_with_metadata] + +import com.google.cloud.modelarmor.v1.CreateTemplateRequest; +import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; +import com.google.cloud.modelarmor.v1.FilterConfig; +import com.google.cloud.modelarmor.v1.LocationName; +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings; +import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter; +import com.google.cloud.modelarmor.v1.RaiFilterType; +import com.google.cloud.modelarmor.v1.Template; +import com.google.cloud.modelarmor.v1.Template.TemplateMetadata; +import java.io.IOException; +import java.util.List; + +public class CreateTemplateWithMetadata { + + public static void main(String[] args) throws IOException { + // TODO(developer): Replace these variables before running the sample. + + // Specify the Google Project ID. + String projectId = "your-project-id"; + // Specify the location ID. For example, us-central1. + String locationId = "your-location-id"; + // Specify the template ID. + String templateId = "your-template-id"; + + createTemplateWithMetadata(projectId, locationId, templateId); + } + + public static Template createTemplateWithMetadata( + String projectId, String locationId, String templateId) throws IOException { + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint) + .build(); + + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + String parent = LocationName.of(projectId, locationId).toString(); + + // Build the Model Armor template with your preferred filters. + // For more details on filters, please refer to the following doc: + // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters + + // Configure Responsible AI filter with multiple categories and their confidence + // levels. + RaiFilterSettings raiFilterSettings = + RaiFilterSettings.newBuilder() + .addAllRaiFilters( + List.of( + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.DANGEROUS) + .setConfidenceLevel(DetectionConfidenceLevel.HIGH) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HATE_SPEECH) + .setConfidenceLevel(DetectionConfidenceLevel.HIGH) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT) + .setConfidenceLevel(DetectionConfidenceLevel.LOW_AND_ABOVE) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HARASSMENT) + .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE) + .build())) + .build(); + + FilterConfig modelArmorFilter = FilterConfig.newBuilder() + .setRaiSettings(raiFilterSettings) + .build(); + + // For more details about metadata, refer to the following documentation: + // https://cloud.google.com/security-command-center/docs/reference/model-armor/rest/v1/projects.locations.templates#templatemetadata + TemplateMetadata templateMetadata = TemplateMetadata.newBuilder() + .setIgnorePartialInvocationFailures(true) + .setLogSanitizeOperations(true) + .setCustomPromptSafetyErrorCode(500) + .build(); + + Template template = Template.newBuilder() + .setFilterConfig(modelArmorFilter) + .setTemplateMetadata(templateMetadata) + .build(); + + CreateTemplateRequest request = CreateTemplateRequest.newBuilder() + .setParent(parent) + .setTemplateId(templateId) + .setTemplate(template) + .build(); + + Template createdTemplate = client.createTemplate(request); + System.out.println("Created template with metadata: " + createdTemplate.getName()); + + return createdTemplate; + } + } +} + +// [END modelarmor_create_template_with_metadata] diff --git a/modelarmor/src/main/java/modelarmor/DeleteTemplate.java b/modelarmor/src/main/java/modelarmor/DeleteTemplate.java new file mode 100644 index 00000000000..e364e626ef4 --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/DeleteTemplate.java @@ -0,0 +1,57 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ + +package modelarmor; + +// [START modelarmor_delete_template] + +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.TemplateName; +import java.io.IOException; + +public class DeleteTemplate { + + public static void main(String[] args) throws IOException { + // TODO(developer): Replace these variables before running the sample. + + // Specify the Google Project ID. + String projectId = "your-project-id"; + // Specify the location ID. For example, us-central1. + String locationId = "your-location-id"; + // Specify the template ID. + String templateId = "your-template-id"; + + deleteTemplate(projectId, locationId, templateId); + } + + public static void deleteTemplate(String projectId, String locationId, String templateId) + throws IOException { + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint) + .build(); + + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + String name = TemplateName.of(projectId, locationId, templateId).toString(); + + // Note: Ensure that the template you are deleting isn't used by any models. + client.deleteTemplate(name); + System.out.println("Deleted template: " + name); + } + } +} + +// [END modelarmor_delete_template] diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplate.java b/modelarmor/src/main/java/modelarmor/UpdateTemplate.java index 64d5eb06e45..5ee9f9dff5e 100644 --- a/modelarmor/src/main/java/modelarmor/UpdateTemplate.java +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplate.java @@ -12,10 +12,12 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ +*/ package modelarmor; +// [START modelarmor_update_template] + import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; import com.google.cloud.modelarmor.v1.FilterConfig; import com.google.cloud.modelarmor.v1.ModelArmorClient; @@ -27,55 +29,88 @@ import com.google.cloud.modelarmor.v1.TemplateName; import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; import com.google.protobuf.FieldMask; -import com.google.protobuf.util.JsonFormat; +import java.io.IOException; import java.util.List; public class UpdateTemplate { - public static void main(String[] args) throws Exception { + public static void main(String[] args) throws IOException { // TODO(developer): Replace these variables before running the sample. + + // Specify the Google Project ID. String projectId = "your-project-id"; + // Specify the location ID. For example, us-central1. String locationId = "your-location-id"; + // Specify the template ID. String templateId = "your-template-id"; updateTemplate(projectId, locationId, templateId); } - public static void updateTemplate(String projectId, String locationId, String templateId) - throws Exception { + public static Template updateTemplate(String projectId, String locationId, String templateId) + throws IOException { + // Construct the API endpoint URL. String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); - ModelArmorSettings modelArmorSettings = - ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint).build(); + ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint) + .build(); + // Initialize the client that will be used to send requests. This client + // only needs to be created once, and can be reused for multiple requests. try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + // Get the template name. String name = TemplateName.of(projectId, locationId, templateId).toString(); - Template template = - Template.newBuilder() - .setName(name) - .setFilterConfig( - FilterConfig.newBuilder() - .setRaiSettings( - RaiFilterSettings.newBuilder() - .addAllRaiFilters( - List.of( - RaiFilter.newBuilder() - .setFilterType(RaiFilterType.HARASSMENT) - .setConfidenceLevel( - DetectionConfidenceLevel.MEDIUM_AND_ABOVE) - .build())) - .build()) - .build()) + // Build the updated Model Armor template with modified filters. + // For more details on filters, please refer to the following doc: + // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters + RaiFilterSettings raiFilterSettings = + RaiFilterSettings.newBuilder() + .addAllRaiFilters( + List.of( + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.DANGEROUS) + .setConfidenceLevel(DetectionConfidenceLevel.HIGH) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HATE_SPEECH) + .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.HARASSMENT) + .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE) + .build(), + RaiFilter.newBuilder() + .setFilterType(RaiFilterType.SEXUALLY_EXPLICIT) + .setConfidenceLevel(DetectionConfidenceLevel.MEDIUM_AND_ABOVE) + .build())) .build(); - UpdateTemplateRequest request = - UpdateTemplateRequest.newBuilder() - .setTemplate(template) - .setUpdateMask(FieldMask.newBuilder().addPaths("filter_config").build()) - .build(); + FilterConfig modelArmorFilter = FilterConfig.newBuilder() + .setRaiSettings(raiFilterSettings) + .build(); + + Template template = Template.newBuilder() + .setName(name) + .setFilterConfig(modelArmorFilter) + .build(); + + // Create a field mask to specify which fields to update. + // Ref: https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask + FieldMask updateMask = FieldMask.newBuilder() + .addPaths("filter_config.rai_settings") + .build(); + + UpdateTemplateRequest request = UpdateTemplateRequest.newBuilder() + .setTemplate(template) + .setUpdateMask(updateMask) + .build(); Template updatedTemplate = client.updateTemplate(request); - System.out.println("Updated template: " + JsonFormat.printer().print(updatedTemplate)); + System.out.println("Updated template: " + updatedTemplate.getName()); + + return updatedTemplate; } } } + +// [END modelarmor_update_template] diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateMetadata.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateMetadata.java deleted file mode 100644 index bfbea5522a0..00000000000 --- a/modelarmor/src/main/java/modelarmor/UpdateTemplateMetadata.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright 2025 Google LLC - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package modelarmor; - -import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; -import com.google.cloud.modelarmor.v1.FilterConfig; -import com.google.cloud.modelarmor.v1.ModelArmorClient; -import com.google.cloud.modelarmor.v1.ModelArmorSettings; -import com.google.cloud.modelarmor.v1.RaiFilterSettings; -import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter; -import com.google.cloud.modelarmor.v1.RaiFilterType; -import com.google.cloud.modelarmor.v1.Template; -import com.google.cloud.modelarmor.v1.TemplateName; -import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; -import com.google.protobuf.util.JsonFormat; -import java.util.List; - -public class UpdateTemplateMetadata { - - public static void main(String[] args) throws Exception { - // TODO(developer): Replace these variables before running the sample. - String projectId = "your-project-id"; - String locationId = "your-location-id"; - String templateId = "your-template-id"; - - updateTemplateMetadata(projectId, locationId, templateId); - } - - public static void updateTemplateMetadata(String projectId, String locationId, String templateId) - throws Exception { - String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); - ModelArmorSettings modelArmorSettings = - ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint).build(); - - try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { - String name = TemplateName.of(projectId, locationId, templateId).toString(); - - Template template = - Template.newBuilder() - .setName(name) - // Ensure the rest of the template is correctly populated as needed. - .setTemplateMetadata( - Template.TemplateMetadata.newBuilder() - .setIgnorePartialInvocationFailures(true) - .setLogSanitizeOperations(true)) - .setFilterConfig( - FilterConfig.newBuilder() - .setRaiSettings( - RaiFilterSettings.newBuilder() - .addAllRaiFilters( - List.of( - RaiFilter.newBuilder() - .setFilterType(RaiFilterType.DANGEROUS) - .setConfidenceLevel(DetectionConfidenceLevel.HIGH) - .build())) - .build()) - .build()) - .build(); - - UpdateTemplateRequest request = - UpdateTemplateRequest.newBuilder() - .setTemplate(template) - // Removed the setUpdateMask line to attempt a full update. - .build(); - - Template updatedTemplate = client.updateTemplate(request); - System.out.println( - "Updated template metadata: " + JsonFormat.printer().print(updatedTemplate)); - } - } -} diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateLabels.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithLabels.java similarity index 52% rename from modelarmor/src/main/java/modelarmor/UpdateTemplateLabels.java rename to modelarmor/src/main/java/modelarmor/UpdateTemplateWithLabels.java index c07c8c5c470..94c24e095aa 100644 --- a/modelarmor/src/main/java/modelarmor/UpdateTemplateLabels.java +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithLabels.java @@ -12,54 +12,81 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ +*/ package modelarmor; +// [START modelarmor_update_template_labels] + import com.google.cloud.modelarmor.v1.ModelArmorClient; import com.google.cloud.modelarmor.v1.ModelArmorSettings; import com.google.cloud.modelarmor.v1.Template; import com.google.cloud.modelarmor.v1.TemplateName; import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; import com.google.protobuf.FieldMask; -import com.google.protobuf.util.JsonFormat; +import java.io.IOException; import java.util.HashMap; import java.util.Map; -public class UpdateTemplateLabels { +public class UpdateTemplateWithLabels { - public static void main(String[] args) throws Exception { + public static void main(String[] args) throws IOException { // TODO(developer): Replace these variables before running the sample. + + // Specify the Google Project ID. String projectId = "your-project-id"; + // Specify the location ID. For example, us-central1. String locationId = "your-location-id"; + // Specify the template ID. String templateId = "your-template-id"; - updateTemplateLabels(projectId, locationId, templateId); + updateTemplateWithLabels(projectId, locationId, templateId); } - public static void updateTemplateLabels(String projectId, String locationId, String templateId) - throws Exception { + public static Template updateTemplateWithLabels(String projectId, String locationId, + String templateId) throws IOException { + // Construct the API endpoint URL. String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); - ModelArmorSettings modelArmorSettings = - ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint).build(); + ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint) + .build(); + + // Initialize the client that will be used to send requests. This client + // only needs to be created once, and can be reused for multiple requests. try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + // Get the template name. String name = TemplateName.of(projectId, locationId, templateId).toString(); + // Create a new labels map. Map labels = new HashMap<>(); - labels.put("key3", "value3"); - labels.put("key4", "value4"); + + // Add or update labels. + labels.put("key1", "value2"); + labels.put("key2", "value3"); - Template template = Template.newBuilder().setName(name).putAllLabels(labels).build(); + // Update the template with the new labels. + Template template = Template.newBuilder() + .setName(name) + .putAllLabels(labels) + .build(); + + // Create a field mask to specify that only labels should be updated. + FieldMask updateMask = FieldMask.newBuilder() + .addPaths("labels") + .build(); UpdateTemplateRequest request = UpdateTemplateRequest.newBuilder() .setTemplate(template) - .setUpdateMask(FieldMask.newBuilder().addPaths("labels").build()) + .setUpdateMask(updateMask) .build(); Template updatedTemplate = client.updateTemplate(request); - System.out.println("Updated template labels: " + JsonFormat.printer().print(updatedTemplate)); + System.out.println("Updated template labels: " + updatedTemplate.getName()); + + return updatedTemplate; } } } + +// [END modelarmor_update_template_labels] diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMaskConfiguration.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMaskConfiguration.java deleted file mode 100644 index 39375e9542e..00000000000 --- a/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMaskConfiguration.java +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright 2025 Google LLC - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package modelarmor; - -import com.google.cloud.modelarmor.v1.DetectionConfidenceLevel; -import com.google.cloud.modelarmor.v1.FilterConfig; -import com.google.cloud.modelarmor.v1.ModelArmorClient; -import com.google.cloud.modelarmor.v1.ModelArmorSettings; -import com.google.cloud.modelarmor.v1.RaiFilterSettings; -import com.google.cloud.modelarmor.v1.RaiFilterSettings.RaiFilter; -import com.google.cloud.modelarmor.v1.RaiFilterType; -import com.google.cloud.modelarmor.v1.Template; -import com.google.cloud.modelarmor.v1.TemplateName; -import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; -import com.google.protobuf.FieldMask; -import com.google.protobuf.util.JsonFormat; -import java.util.List; - -public class UpdateTemplateWithMaskConfiguration { - - public static void main(String[] args) throws Exception { - // TODO(developer): Replace these variables before running the sample. - String projectId = "your-project-id"; - String locationId = "your-location-id"; - String templateId = "your-template-id"; - - updateTemplateWithMaskConfiguration(projectId, locationId, templateId); - } - - public static void updateTemplateWithMaskConfiguration( - String projectId, String locationId, String templateId) throws Exception { - String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); - ModelArmorSettings modelArmorSettings = - ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint).build(); - - try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { - String name = TemplateName.of(projectId, locationId, templateId).toString(); - - Template template = - Template.newBuilder() - .setName(name) - .setFilterConfig( - FilterConfig.newBuilder() - .setRaiSettings( - RaiFilterSettings.newBuilder() - .addAllRaiFilters( - List.of( - RaiFilter.newBuilder() - .setFilterType(RaiFilterType.HARASSMENT) - .setConfidenceLevel( - DetectionConfidenceLevel.MEDIUM_AND_ABOVE) - .build())) - .build()) - .build()) - .build(); - - UpdateTemplateRequest request = - UpdateTemplateRequest.newBuilder() - .setTemplate(template) - .setUpdateMask( - FieldMask.newBuilder().addPaths("filter_config.rai_settings.rai_filters").build()) - .build(); - - Template updatedTemplate = client.updateTemplate(request); - System.out.println( - "Updated template with mask configuration: " - + JsonFormat.printer().print(updatedTemplate)); - } - } -} diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMetadata.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMetadata.java new file mode 100644 index 00000000000..5c3dbe2d3a5 --- /dev/null +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMetadata.java @@ -0,0 +1,92 @@ +/* + * Copyright 2025 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ + +package modelarmor; + +// [START modelarmor_update_template_metadata] + +import com.google.cloud.modelarmor.v1.ModelArmorClient; +import com.google.cloud.modelarmor.v1.ModelArmorSettings; +import com.google.cloud.modelarmor.v1.Template; +import com.google.cloud.modelarmor.v1.Template.TemplateMetadata; +import com.google.cloud.modelarmor.v1.TemplateName; +import com.google.cloud.modelarmor.v1.UpdateTemplateRequest; +import com.google.protobuf.FieldMask; +import java.io.IOException; + +public class UpdateTemplateWithMetadata { + + public static void main(String[] args) throws IOException { + // TODO(developer): Replace these variables before running the sample. + + // Specify the Google Project ID. + String projectId = "your-project-id"; + // Specify the location ID. For example, us-central1. + String locationId = "your-location-id"; + // Specify the template ID. + String templateId = "your-template-id"; + + updateTemplateWithMetadata(projectId, locationId, templateId); + } + + public static Template updateTemplateWithMetadata(String projectId, String locationId, + String templateId) throws IOException { + // Construct the API endpoint URL. + String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId); + + ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint) + .build(); + + // Initialize the client that will be used to send requests. This client + // only needs to be created once, and can be reused for multiple requests. + try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) { + // Get the template name. + String name = TemplateName.of(projectId, locationId, templateId).toString(); + + // For more details about metadata, refer to the following documentation: + // https://cloud.google.com/security-command-center/docs/reference/model-armor/rest/v1/projects.locations.templates#templatemetadata + TemplateMetadata updatedMetadata = TemplateMetadata.newBuilder() + .setIgnorePartialInvocationFailures(false) + .setLogSanitizeOperations(false) + .setCustomPromptSafetyErrorCode(400) + .build(); + + // Update the template with new metadata. + Template template = Template.newBuilder() + .setName(name) + .setTemplateMetadata(updatedMetadata) + .build(); + + // Create a field mask to specify which metadata fields should be updated. + FieldMask updateMask = FieldMask.newBuilder() + .addPaths("template_metadata") + .build(); + + UpdateTemplateRequest request = + UpdateTemplateRequest.newBuilder() + .setTemplate(template) + .setUpdateMask(updateMask) + .build(); + + Template updatedTemplate = client.updateTemplate(request); + System.out.println("Updated template metadata: " + updatedTemplate.getName()); + + return updatedTemplate; + } + } +} + +// [END modelarmor_update_template_metadata] diff --git a/modelarmor/src/test/java/modelarmor/SnippetsIT.java b/modelarmor/src/test/java/modelarmor/SnippetsIT.java index 9461ec74bc8..4c8650d5de2 100644 --- a/modelarmor/src/test/java/modelarmor/SnippetsIT.java +++ b/modelarmor/src/test/java/modelarmor/SnippetsIT.java @@ -12,17 +12,21 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ +*/ package modelarmor; import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertEquals; +import com.google.api.gax.rpc.NotFoundException; import com.google.cloud.modelarmor.v1.Template; +import com.google.cloud.modelarmor.v1.TemplateName; import com.google.common.base.Strings; import java.io.ByteArrayOutputStream; +import java.io.IOException; import java.io.PrintStream; -import java.util.UUID; +import java.util.Random; import org.junit.After; import org.junit.AfterClass; import org.junit.Assert; @@ -34,34 +38,24 @@ /** Integration (system) tests for {@link Snippets}. */ @RunWith(JUnit4.class) -@SuppressWarnings("checkstyle:AbbreviationAsWordInName") public class SnippetsIT { - private static final String PROJECT_ID = System.getenv("GOOGLE_CLOUD_PROJECT"); - private static final String LOCATION = "us-central1"; - private static final String MA_REGIONAL_ENDPOINT = - String.format("modelarmor.%s.rep.googleapis.com:443", LOCATION); - private static final String DLP_REGIONAL_ENDPOINT = - String.format("dlp.%s.rep.googleapis.com:443", LOCATION); - private static final String INSPECT_TEMPLATE_ID = - "model-armour-inspect-template-" + UUID.randomUUID().toString(); - private static final String DEIDENTIFY_TEMPLATE_ID = - "model-armour-deidentify-template-" + UUID.randomUUID().toString(); - private static Template TEST_MODELARMOR_TEMPLATE; - private static Template TEST_MODELARMOR_TEMPLATE_NAME; - private static String TEMPLATE_ID; - + private static final String LOCATION_ID = System.getenv() + .getOrDefault("GOOGLE_CLOUD_PROJECT_LOCATION", "us-central1"); + private static String TEST_TEMPLATE_ID; + private static String TEST_TEMPLATE_NAME; private ByteArrayOutputStream stdOut; @BeforeClass - public static void beforeAll() throws Exception { + public static void beforeAll() throws IOException { Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT", Strings.isNullOrEmpty(PROJECT_ID)); - Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT_LOCATION", Strings.isNullOrEmpty(LOCATION)); + Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT_LOCATION", Strings.isNullOrEmpty(LOCATION_ID)); } @AfterClass - public static void afterAll() throws Exception { + public static void afterAll() throws IOException { Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT", Strings.isNullOrEmpty(PROJECT_ID)); + Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT_LOCATION", Strings.isNullOrEmpty(LOCATION_ID)); } @Before @@ -69,45 +63,65 @@ public void beforeEach() { stdOut = new ByteArrayOutputStream(); System.setOut(new PrintStream(stdOut)); - TEMPLATE_ID = "test-model-armor-" + UUID.randomUUID().toString(); + TEST_TEMPLATE_ID = randomId(); + TEST_TEMPLATE_NAME = TemplateName.of(PROJECT_ID, LOCATION_ID, TEST_TEMPLATE_ID).toString(); } @After - public void afterEach() throws Exception { + public void afterEach() throws IOException { + + try { + DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION_ID, TEST_TEMPLATE_ID); + } catch (NotFoundException e) { + // Ignore not found error - template already deleted. + } + stdOut = null; System.setOut(null); } - @Test - public void testUpdateModelArmorTemplate() throws Exception { - CreateTemplate.createTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); - UpdateTemplate.updateTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); - assertThat(stdOut.toString()).contains("Updated template"); - DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + private static String randomId() { + Random random = new Random(); + return "java-ma-" + random.nextLong(); } @Test - public void testUpdateModelArmorTemplateWithLabels() throws Exception { - CreateTemplate.createTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); - UpdateTemplateLabels.updateTemplateLabels(PROJECT_ID, LOCATION, TEMPLATE_ID); - assertThat(stdOut.toString()).contains("Updated template labels"); - DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + public void testUpdateModelArmorTemplate() throws IOException { + CreateTemplate.createTemplate(PROJECT_ID, LOCATION_ID, TEST_TEMPLATE_ID); + + // Update the existing template. + Template updatedTemplate = UpdateTemplate.updateTemplate(PROJECT_ID, LOCATION_ID, + TEST_TEMPLATE_ID); + + assertThat(stdOut.toString()).contains("Updated template:"); + assertEquals(updatedTemplate.getName(), TEST_TEMPLATE_NAME); } @Test - public void testUpdateModelArmorTemplateWithMetadata() throws Exception { - CreateTemplate.createTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); - UpdateTemplateMetadata.updateTemplateMetadata(PROJECT_ID, LOCATION, TEMPLATE_ID); - assertThat(stdOut.toString()).contains("Updated template metadata"); - DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + public void testUpdateModelArmorTemplateWithLabels() throws IOException { + CreateTemplateWithLabels.createTemplateWithLabels(PROJECT_ID, LOCATION_ID, TEST_TEMPLATE_ID); + + // Update the existing template. + Template updatedTemplate = UpdateTemplateWithLabels.updateTemplateWithLabels(PROJECT_ID, + LOCATION_ID, TEST_TEMPLATE_ID); + + assertThat(stdOut.toString()).contains("Updated template labels:"); + assertEquals(updatedTemplate.getName(), TEST_TEMPLATE_NAME); } @Test - public void testUpdateModelArmorTemplateWithMaskConfiguration() throws Exception { - CreateTemplate.createTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); - UpdateTemplateWithMaskConfiguration.updateTemplateWithMaskConfiguration( - PROJECT_ID, LOCATION, TEMPLATE_ID); - assertThat(stdOut.toString()).contains("Updated template with mask configuration"); - DeleteTemplate.deleteTemplate(PROJECT_ID, LOCATION, TEMPLATE_ID); + public void testUpdateModelArmorTemplateWithMetadata() throws IOException { + CreateTemplateWithMetadata.createTemplateWithMetadata(PROJECT_ID, LOCATION_ID, + TEST_TEMPLATE_ID); + + // Update the existing template. + Template updatedTemplate = UpdateTemplateWithMetadata.updateTemplateWithMetadata(PROJECT_ID, + LOCATION_ID, TEST_TEMPLATE_ID); + + assertThat(stdOut.toString()).contains("Updated template metadata:"); + assertEquals(updatedTemplate.getName(), TEST_TEMPLATE_NAME); + assertEquals(false, updatedTemplate.getTemplateMetadata().getIgnorePartialInvocationFailures()); + assertEquals(false, updatedTemplate.getTemplateMetadata().getLogSanitizeOperations()); + assertEquals(400, updatedTemplate.getTemplateMetadata().getCustomPromptSafetyErrorCode()); } } From e03eedfc6ea9ba5e071355de04b653e19e0902b2 Mon Sep 17 00:00:00 2001 From: Harsh Nasit Date: Wed, 16 Apr 2025 19:06:27 +0530 Subject: [PATCH 3/6] sync-requireenvvar-function --- .../src/test/java/modelarmor/SnippetsIT.java | 21 ++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/modelarmor/src/test/java/modelarmor/SnippetsIT.java b/modelarmor/src/test/java/modelarmor/SnippetsIT.java index 4c8650d5de2..166469a6607 100644 --- a/modelarmor/src/test/java/modelarmor/SnippetsIT.java +++ b/modelarmor/src/test/java/modelarmor/SnippetsIT.java @@ -18,18 +18,17 @@ import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; import com.google.api.gax.rpc.NotFoundException; import com.google.cloud.modelarmor.v1.Template; import com.google.cloud.modelarmor.v1.TemplateName; -import com.google.common.base.Strings; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream; import java.util.Random; import org.junit.After; import org.junit.AfterClass; -import org.junit.Assert; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; @@ -46,16 +45,24 @@ public class SnippetsIT { private static String TEST_TEMPLATE_NAME; private ByteArrayOutputStream stdOut; + // Check if the required environment variables are set. + private static String requireEnvVar(String varName) { + String value = System.getenv(varName); + assertNotNull("Environment variable " + varName + " is required to run these tests.", + System.getenv(varName)); + return value; + } + @BeforeClass - public static void beforeAll() throws IOException { - Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT", Strings.isNullOrEmpty(PROJECT_ID)); - Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT_LOCATION", Strings.isNullOrEmpty(LOCATION_ID)); + public static void beforeAll() { + requireEnvVar("GOOGLE_CLOUD_PROJECT"); + requireEnvVar("GOOGLE_CLOUD_PROJECT_LOCATION"); } @AfterClass public static void afterAll() throws IOException { - Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT", Strings.isNullOrEmpty(PROJECT_ID)); - Assert.assertFalse("missing GOOGLE_CLOUD_PROJECT_LOCATION", Strings.isNullOrEmpty(LOCATION_ID)); + requireEnvVar("GOOGLE_CLOUD_PROJECT"); + requireEnvVar("GOOGLE_CLOUD_PROJECT_LOCATION"); } @Before From 3377636f1428e5c461c57d859285f132ac47fda4 Mon Sep 17 00:00:00 2001 From: harshnasitcrest <131268456+harshnasitcrest@users.noreply.github.com> Date: Thu, 17 Apr 2025 16:02:28 +0530 Subject: [PATCH 4/6] remove-require-env-location-condition --- modelarmor/src/test/java/modelarmor/SnippetsIT.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/modelarmor/src/test/java/modelarmor/SnippetsIT.java b/modelarmor/src/test/java/modelarmor/SnippetsIT.java index 166469a6607..ac82123a272 100644 --- a/modelarmor/src/test/java/modelarmor/SnippetsIT.java +++ b/modelarmor/src/test/java/modelarmor/SnippetsIT.java @@ -56,13 +56,11 @@ private static String requireEnvVar(String varName) { @BeforeClass public static void beforeAll() { requireEnvVar("GOOGLE_CLOUD_PROJECT"); - requireEnvVar("GOOGLE_CLOUD_PROJECT_LOCATION"); } @AfterClass public static void afterAll() throws IOException { requireEnvVar("GOOGLE_CLOUD_PROJECT"); - requireEnvVar("GOOGLE_CLOUD_PROJECT_LOCATION"); } @Before From 0706e768c6115a9c0e279a891cbe222d5d3fe66c Mon Sep 17 00:00:00 2001 From: Harsh Nasit Date: Fri, 18 Apr 2025 13:02:04 +0530 Subject: [PATCH 5/6] address-review-comment --- .../src/main/java/modelarmor/UpdateTemplateWithLabels.java | 2 +- .../src/main/java/modelarmor/UpdateTemplateWithMetadata.java | 2 +- modelarmor/src/test/java/modelarmor/SnippetsIT.java | 4 ---- 3 files changed, 2 insertions(+), 6 deletions(-) diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateWithLabels.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithLabels.java index 94c24e095aa..8d5850dd753 100644 --- a/modelarmor/src/main/java/modelarmor/UpdateTemplateWithLabels.java +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithLabels.java @@ -82,7 +82,7 @@ public static Template updateTemplateWithLabels(String projectId, String locatio .build(); Template updatedTemplate = client.updateTemplate(request); - System.out.println("Updated template labels: " + updatedTemplate.getName()); + System.out.println("Updated labels of template: " + updatedTemplate.getName()); return updatedTemplate; } diff --git a/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMetadata.java b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMetadata.java index 5c3dbe2d3a5..8fc3563d3be 100644 --- a/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMetadata.java +++ b/modelarmor/src/main/java/modelarmor/UpdateTemplateWithMetadata.java @@ -82,7 +82,7 @@ public static Template updateTemplateWithMetadata(String projectId, String locat .build(); Template updatedTemplate = client.updateTemplate(request); - System.out.println("Updated template metadata: " + updatedTemplate.getName()); + System.out.println("Updated metadata of template: " + updatedTemplate.getName()); return updatedTemplate; } diff --git a/modelarmor/src/test/java/modelarmor/SnippetsIT.java b/modelarmor/src/test/java/modelarmor/SnippetsIT.java index ac82123a272..ee0ad6d9cae 100644 --- a/modelarmor/src/test/java/modelarmor/SnippetsIT.java +++ b/modelarmor/src/test/java/modelarmor/SnippetsIT.java @@ -16,7 +16,6 @@ package modelarmor; -import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -98,7 +97,6 @@ public void testUpdateModelArmorTemplate() throws IOException { Template updatedTemplate = UpdateTemplate.updateTemplate(PROJECT_ID, LOCATION_ID, TEST_TEMPLATE_ID); - assertThat(stdOut.toString()).contains("Updated template:"); assertEquals(updatedTemplate.getName(), TEST_TEMPLATE_NAME); } @@ -110,7 +108,6 @@ public void testUpdateModelArmorTemplateWithLabels() throws IOException { Template updatedTemplate = UpdateTemplateWithLabels.updateTemplateWithLabels(PROJECT_ID, LOCATION_ID, TEST_TEMPLATE_ID); - assertThat(stdOut.toString()).contains("Updated template labels:"); assertEquals(updatedTemplate.getName(), TEST_TEMPLATE_NAME); } @@ -123,7 +120,6 @@ public void testUpdateModelArmorTemplateWithMetadata() throws IOException { Template updatedTemplate = UpdateTemplateWithMetadata.updateTemplateWithMetadata(PROJECT_ID, LOCATION_ID, TEST_TEMPLATE_ID); - assertThat(stdOut.toString()).contains("Updated template metadata:"); assertEquals(updatedTemplate.getName(), TEST_TEMPLATE_NAME); assertEquals(false, updatedTemplate.getTemplateMetadata().getIgnorePartialInvocationFailures()); assertEquals(false, updatedTemplate.getTemplateMetadata().getLogSanitizeOperations()); From c34aea945e2370930db228a942b496f2d6e55f94 Mon Sep 17 00:00:00 2001 From: Harsh Nasit Date: Fri, 9 May 2025 00:31:27 +0530 Subject: [PATCH 6/6] fix-lint-post-merge-conflicts --- modelarmor/src/test/java/modelarmor/SnippetsIT.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/modelarmor/src/test/java/modelarmor/SnippetsIT.java b/modelarmor/src/test/java/modelarmor/SnippetsIT.java index 5fccc234a1f..f9ed4cf23b4 100644 --- a/modelarmor/src/test/java/modelarmor/SnippetsIT.java +++ b/modelarmor/src/test/java/modelarmor/SnippetsIT.java @@ -331,10 +331,10 @@ private static DeidentifyTemplate createDeidentifyTemplate(String templateId) th CreateDeidentifyTemplateRequest createDeidentifyTemplateRequest = CreateDeidentifyTemplateRequest.newBuilder() - .setParent(LocationName.of(PROJECT_ID, LOCATION_ID).toString()) - .setTemplateId(templateId) - .setDeidentifyTemplate(deidentifyTemplate) - .build(); + .setParent(LocationName.of(PROJECT_ID, LOCATION_ID).toString()) + .setTemplateId(templateId) + .setDeidentifyTemplate(deidentifyTemplate) + .build(); return dlpServiceClient.createDeidentifyTemplate(createDeidentifyTemplateRequest); }