Merge branch 'main' into renovate/kubernetes-go

Author: glasnt

bigtable/deletes/delete_streaming_batching.go

@@ -0,0 +1,89 @@
+// 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
+//
+//     https://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 deletes
+
+// [START bigtable_streaming_and_batching_asyncio]
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"cloud.google.com/go/bigtable"
+)
+
+// streamingAndBatching starts a stream of data (reading rows), batches them, and then goes through the batch and deletes all the cells in column
+func streamingAndBatching(w io.Writer, projectID, instanceID string, tableName string) error {
+	// projectID := "my-project-id"
+	// instanceID := "my-instance-id"
+	// tableName := "mobile-time-series"
+
+	ctx := context.Background()
+	client, err := bigtable.NewClient(ctx, projectID, instanceID)
+	if err != nil {
+		return fmt.Errorf("bigtable.NewClient: %w", err)
+	}
+	defer client.Close()
+	tbl := client.Open(tableName)
+
+	// Slices to hold the row keys and the corresponding mutations.
+	var rowKeys []string
+	var mutations []*bigtable.Mutation
+
+	// Read all rows from the table.
+	err = tbl.ReadRows(ctx, bigtable.InfiniteRange(""), func(row bigtable.Row) bool {
+		// For each row, create a mutation to delete the specified cell.
+		mut := bigtable.NewMutation()
+		mut.DeleteCellsInColumn("cell_plan", "data_plan_01gb")
+
+		// Append the row key and mutation to the slices.
+		rowKeys = append(rowKeys, row.Key())
+		mutations = append(mutations, mut)
+
+		// Continue processing rows.
+		return true
+	})
+	if err != nil {
+		return fmt.Errorf("tbl.ReadRows: %w", err)
+	}
+
+	if len(mutations) == 0 {
+		return nil
+	}
+	// If there are mutations to apply, apply them in a single bulk request.
+	// ApplyBulk returns a slice of errors, one for each mutation.
+	var errs []error
+	if errs, err = tbl.ApplyBulk(ctx, rowKeys, mutations); err != nil {
+		return fmt.Errorf("tbl.ApplyBulk: %w", err)
+	}
+	if errs != nil {
+		// Log any individual errors that occurred during the bulk operation.
+		var errorCount int
+		for _, individualErr := range errs {
+			if individualErr != nil {
+				fmt.Fprintf(w, "Error applying mutation: %v\n", individualErr)
+				errorCount++
+			}
+		}
+		if errorCount > 0 {
+			return fmt.Errorf("encountered %d error(s) out of %d mutations", errorCount, len(errs))
+		}
+	}
+
+	fmt.Fprintf(w, "Successfully deleted cells from all rows")
+	return nil
+}
+
+// [END bigtable_streaming_and_batching_asyncio]

bigtable/deletes/delete_streaming_batching_test.go

@@ -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
+//
+//     https://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 deletes
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/bigtable"
+	"github.com/GoogleCloudPlatform/golang-samples/internal/testutil"
+	"github.com/google/uuid"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func TestStreamingAndBatching(t *testing.T) {
+	ctx := context.Background()
+	project := os.Getenv("GOLANG_SAMPLES_BIGTABLE_PROJECT")
+	instance := os.Getenv("GOLANG_SAMPLES_BIGTABLE_INSTANCE")
+	if project == "" || instance == "" {
+		t.Fatal("Failed Bigtable integration test. Set GOLANG_SAMPLES_BIGTABLE_PROJECT and GOLANG_SAMPLES_BIGTABLE_INSTANCE.")
+	}
+
+	// Create client
+	adminClient, err := bigtable.NewAdminClient(ctx, project, instance)
+	if err != nil {
+		t.Fatalf("bigtable.NewAdminClient: %v", err)
+	}
+
+	// Create table
+	tableName := "mobile-time-series-" + uuid.New().String()[:8]
+	if err := adminClient.DeleteTable(ctx, tableName); err != nil && status.Code(err) != codes.NotFound {
+		t.Fatalf("adminClient.DeleteTable(%q): %v", tableName, err)
+	}
+	testutil.Retry(t, 10, 10*time.Second, func(r *testutil.R) {
+		if err := adminClient.CreateTable(ctx, tableName); err != nil {
+			if status.Code(err) == codes.AlreadyExists {
+				adminClient.DeleteTable(ctx, tableName)
+				time.Sleep(5 * time.Second)
+			}
+			r.Errorf("Could not create table %s: %v", tableName, err)
+		}
+	})
+	if t.Failed() {
+		return
+	}
+	defer adminClient.DeleteTable(ctx, tableName)
+
+	// Create column family
+	columnFamilyName := "cell_plan"
+	if err := adminClient.CreateColumnFamily(ctx, tableName, columnFamilyName); err != nil {
+		t.Fatalf("CreateColumnFamily(%s): %v", columnFamilyName, err)
+	}
+
+	// Write test data
+	client, err := bigtable.NewClient(ctx, project, instance)
+	if err != nil {
+		t.Fatalf("bigtable.NewClient: %v", err)
+	}
+	defer client.Close()
+	tbl := client.Open(tableName)
+	rowKeys := []string{"phone#4c410523#20190501", "phone#5c10102#20190501"}
+	muts := make([]*bigtable.Mutation, len(rowKeys))
+	for i := range rowKeys {
+		mut := bigtable.NewMutation()
+		mut.Set(columnFamilyName, "data_plan_01gb", 0, []byte("true"))
+		mut.Set(columnFamilyName, "data_plan_05gb", 0, []byte("true"))
+		muts[i] = mut
+	}
+	if _, err := tbl.ApplyBulk(ctx, rowKeys, muts); err != nil {
+		t.Fatalf("tbl.ApplyBulk: %v", err)
+	}
+
+	// Run the function
+	buf := new(bytes.Buffer)
+	if err := streamingAndBatching(buf, project, instance, tableName); err != nil {
+		t.Errorf("streamingAndBatching failed: %v", err)
+	}
+
+	// Verify the output message
+	if got, want := buf.String(), "Successfully deleted cells from all rows"; !strings.Contains(got, want) {
+		t.Errorf("streamingAndBatching output got %q, want substring %q", got, want)
+	}
+
+	// Verify that the cells were deleted
+	for _, rowKey := range rowKeys {
+		row, err := tbl.ReadRow(ctx, rowKey)
+		if err != nil {
+			t.Fatalf("tbl.ReadRow(%q): %v", rowKey, err)
+		}
+		if _, ok := row[columnFamilyName]; !ok {
+			t.Errorf("row %q has no column family %q", rowKey, columnFamilyName)
+			continue
+		}
+		for _, item := range row[columnFamilyName] {
+			if item.Column == fmt.Sprintf("%s:data_plan_01gb", columnFamilyName) {
+				t.Errorf("row %q still has cell %s:data_plan_01gb", rowKey, columnFamilyName)
+			}
+		}
+	}
+}

genai/content_cache/contentcache_create_with_txt_gcs_pdf.go

@@ -21,6 +21,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"time"
 
 	genai "google.golang.org/genai"
 )
@@ -65,7 +66,7 @@ func createContentCache(w io.Writer) (string, error) {
 			},
 		},
 		DisplayName: "example-cache",
-		TTL:         "86400s",
+		TTL:         time.Duration(time.Duration.Seconds(86400)),
 	}
 
 	res, err := client.Caches.Create(ctx, modelName, config)

genai/content_cache/contentcache_update.go

@@ -38,26 +38,26 @@ func updateContentCache(w io.Writer, cacheName string) error {
 
 	// Update expire time using TTL
 	resp, err := client.Caches.Update(ctx, cacheName, &genai.UpdateCachedContentConfig{
-		TTL: "36000s",
+		TTL: time.Duration(time.Duration.Seconds(36000)),
 	})
 	if err != nil {
 		return fmt.Errorf("failed to update content cache exp. time with TTL: %w", err)
 	}
 
-	fmt.Fprintf(w, "Cache expires in: %s\n", time.Until(*resp.ExpireTime))
+	fmt.Fprintf(w, "Cache expires in: %s\n", time.Until(resp.ExpireTime))
 	// Example response:
 	// Cache expires in: 10h0m0.005875s
 
 	// Update expire time using specific time stamp
 	inSevenDays := time.Now().Add(7 * 24 * time.Hour)
 	resp, err = client.Caches.Update(ctx, cacheName, &genai.UpdateCachedContentConfig{
-		ExpireTime: &inSevenDays,
+		ExpireTime: inSevenDays,
 	})
 	if err != nil {
 		return fmt.Errorf("failed to update content cache expire time: %w", err)
 	}
 
-	fmt.Fprintf(w, "Cache expires in: %s\n", time.Until(*resp.ExpireTime))
+	fmt.Fprintf(w, "Cache expires in: %s\n", time.Until(resp.ExpireTime))
 	// Example response:
 	// Cache expires in: 167h59m59.80327s
 

genai/content_cache/contentcache_use_with_txt.go

@@ -46,10 +46,8 @@ func useContentCacheWithTxt(w io.Writer, cacheName string) error {
 		return fmt.Errorf("failed to use content cache to generate content: %w", err)
 	}
 
-	respText, err := resp.Text()
-	if err != nil {
-		return fmt.Errorf("failed to convert model response to text: %w", err)
-	}
+	respText := resp.Text()
+
 	fmt.Fprintln(w, respText)
 
 	// Example response:

genai/controlled_generation/ctrlgen_with_enum_schema.go

@@ -39,7 +39,7 @@ func generateWithEnumSchema(w io.Writer) error {
 	contents := []*genai.Content{
 		{Parts: []*genai.Part{
 			{Text: "What type of instrument is an oboe?"},
-		}},
+		}, Role: "user"},
 	}
 	config := &genai.GenerateContentConfig{
 		ResponseMIMEType: "text/x.enum",
@@ -54,10 +54,8 @@ func generateWithEnumSchema(w io.Writer) error {
 		return fmt.Errorf("failed to generate content: %w", err)
 	}
 
-	respText, err := resp.Text()
-	if err != nil {
-		return fmt.Errorf("failed to convert model response to text: %w", err)
-	}
+	respText := resp.Text()
+
 	fmt.Fprintln(w, respText)
 
 	// Example response:

genai/controlled_generation/ctrlgen_with_nullable_schema.go

@@ -49,7 +49,8 @@ Finally, Saturday rounds off the week with sunny skies, a temperature of 80°F,
 	contents := []*genai.Content{
 		{Parts: []*genai.Part{
 			{Text: prompt},
-		}},
+		},
+			Role: "user"},
 	}
 	config := &genai.GenerateContentConfig{
 		ResponseMIMEType: "application/json",
@@ -63,11 +64,11 @@ Finally, Saturday rounds off the week with sunny skies, a temperature of 80°F,
 					Items: &genai.Schema{
 						Type: "object",
 						Properties: map[string]*genai.Schema{
-							"Day":         {Type: "string", Nullable: true},
-							"Forecast":    {Type: "string", Nullable: true},
-							"Temperature": {Type: "integer", Nullable: true},
-							"Humidity":    {Type: "string", Nullable: true},
-							"Wind Speed":  {Type: "integer", Nullable: true},
+							"Day":         {Type: "string", Nullable: genai.Ptr(true)},
+							"Forecast":    {Type: "string", Nullable: genai.Ptr(true)},
+							"Temperature": {Type: "integer", Nullable: genai.Ptr(true)},
+							"Humidity":    {Type: "string", Nullable: genai.Ptr(true)},
+							"Wind Speed":  {Type: "integer", Nullable: genai.Ptr(true)},
 						},
 						Required: []string{"Day", "Temperature", "Forecast", "Wind Speed"},
 					},
@@ -81,10 +82,8 @@ Finally, Saturday rounds off the week with sunny skies, a temperature of 80°F,
 		return fmt.Errorf("failed to generate content: %w", err)
 	}
 
-	respText, err := resp.Text()
-	if err != nil {
-		return fmt.Errorf("failed to convert model response to text: %w", err)
-	}
+	respText := resp.Text()
+
 	fmt.Fprintln(w, respText)
 
 	// Example response:

genai/controlled_generation/ctrlgen_with_resp_schema.go

@@ -57,7 +57,8 @@ func generateWithRespSchema(w io.Writer) error {
 	contents := []*genai.Content{
 		{Parts: []*genai.Part{
 			{Text: "List a few popular cookie recipes."},
-		}},
+		},
+			Role: "user"},
 	}
 	modelName := "gemini-2.0-flash-001"
 
@@ -66,10 +67,8 @@ func generateWithRespSchema(w io.Writer) error {
 		return fmt.Errorf("failed to generate content: %w", err)
 	}
 
-	respText, err := resp.Text()
-	if err != nil {
-		return fmt.Errorf("failed to convert model response to text: %w", err)
-	}
+	respText := resp.Text()
+
 	fmt.Fprintln(w, respText)
 
 	// Example response:

genai/count_tokens/counttoken_compute_with_txt.go

@@ -40,7 +40,8 @@ func computeWithTxt(w io.Writer) error {
 	contents := []*genai.Content{
 		{Parts: []*genai.Part{
 			{Text: "What's the longest word in the English language?"},
-		}},
+		},
+			Role: "user"},
 	}
 
 	resp, err := client.Models.ComputeTokens(ctx, modelName, contents, nil)

genai/count_tokens/counttoken_resp_with_txt.go

@@ -40,7 +40,8 @@ func generateTextAndCount(w io.Writer) error {
 	contents := []*genai.Content{
 		{Parts: []*genai.Part{
 			{Text: "Why is the sky blue?"},
-		}},
+		},
+			Role: "user"},
 	}
 
 	resp, err := client.Models.GenerateContent(ctx, modelName, contents, nil)