diff --git a/samples/samples/autocommit.py b/samples/samples/autocommit.py
index d5c44b0c53..873ed2b7bd 100644
--- a/samples/samples/autocommit.py
+++ b/samples/samples/autocommit.py
@@ -46,11 +46,14 @@ def enable_autocommit_mode(instance_id, database_id):
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
-        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter,
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.add_argument("instance_id", help="Your Cloud Spanner instance ID.")
     parser.add_argument(
-        "--database-id", help="Your Cloud Spanner database ID.", default="example_db",
+        "--database-id",
+        help="Your Cloud Spanner database ID.",
+        default="example_db",
     )
     subparsers = parser.add_subparsers(dest="command")
     subparsers.add_parser("enable_autocommit_mode", help=enable_autocommit_mode.__doc__)
diff --git a/samples/samples/autocommit_test.py b/samples/samples/autocommit_test.py
index 6b102da8fe..8150058f1c 100644
--- a/samples/samples/autocommit_test.py
+++ b/samples/samples/autocommit_test.py
@@ -25,7 +25,8 @@ def test_enable_autocommit_mode(capsys, instance_id, sample_database):
         op.result()
 
     autocommit.enable_autocommit_mode(
-        instance_id, sample_database.database_id,
+        instance_id,
+        sample_database.database_id,
     )
     out, _ = capsys.readouterr()
     assert "Autocommit mode is enabled." in out
diff --git a/samples/samples/backup_sample_test.py b/samples/samples/backup_sample_test.py
index da50fbba46..5f094e7a77 100644
--- a/samples/samples/backup_sample_test.py
+++ b/samples/samples/backup_sample_test.py
@@ -26,12 +26,12 @@ def sample_name():
 
 
 def unique_database_id():
-    """ Creates a unique id for the database. """
+    """Creates a unique id for the database."""
     return f"test-db-{uuid.uuid4().hex[:10]}"
 
 
 def unique_backup_id():
-    """ Creates a unique id for the backup. """
+    """Creates a unique id for the backup."""
     return f"test-backup-{uuid.uuid4().hex[:10]}"
 
 
@@ -52,7 +52,10 @@ def test_create_backup(capsys, instance_id, sample_database):
         version_time = list(results)[0][0]
 
     backup_sample.create_backup(
-        instance_id, sample_database.database_id, BACKUP_ID, version_time,
+        instance_id,
+        sample_database.database_id,
+        BACKUP_ID,
+        version_time,
     )
     out, _ = capsys.readouterr()
     assert BACKUP_ID in out
@@ -74,10 +77,16 @@ def test_copy_backup(capsys, instance_id, spanner_client):
 
 @pytest.mark.dependency(name="create_backup_with_encryption_key")
 def test_create_backup_with_encryption_key(
-    capsys, instance_id, sample_database, kms_key_name,
+    capsys,
+    instance_id,
+    sample_database,
+    kms_key_name,
 ):
     backup_sample.create_backup_with_encryption_key(
-        instance_id, sample_database.database_id, CMEK_BACKUP_ID, kms_key_name,
+        instance_id,
+        sample_database.database_id,
+        CMEK_BACKUP_ID,
+        kms_key_name,
     )
     out, _ = capsys.readouterr()
     assert CMEK_BACKUP_ID in out
@@ -97,7 +106,10 @@ def test_restore_database(capsys, instance_id, sample_database):
 @pytest.mark.dependency(depends=["create_backup_with_encryption_key"])
 @RetryErrors(exception=DeadlineExceeded, max_tries=2)
 def test_restore_database_with_encryption_key(
-    capsys, instance_id, sample_database, kms_key_name,
+    capsys,
+    instance_id,
+    sample_database,
+    kms_key_name,
 ):
     backup_sample.restore_database_with_encryption_key(
         instance_id, CMEK_RESTORE_DB_ID, CMEK_BACKUP_ID, kms_key_name
@@ -123,10 +135,14 @@ def test_list_backup_operations(capsys, instance_id, sample_database):
 
 @pytest.mark.dependency(name="list_backup", depends=["create_backup", "copy_backup"])
 def test_list_backups(
-    capsys, instance_id, sample_database,
+    capsys,
+    instance_id,
+    sample_database,
 ):
     backup_sample.list_backups(
-        instance_id, sample_database.database_id, BACKUP_ID,
+        instance_id,
+        sample_database.database_id,
+        BACKUP_ID,
     )
     out, _ = capsys.readouterr()
     id_count = out.count(BACKUP_ID)
@@ -153,7 +169,9 @@ def test_delete_backup(capsys, instance_id):
 @pytest.mark.dependency(depends=["create_backup"])
 def test_cancel_backup(capsys, instance_id, sample_database):
     backup_sample.cancel_backup(
-        instance_id, sample_database.database_id, BACKUP_ID,
+        instance_id,
+        sample_database.database_id,
+        BACKUP_ID,
     )
     out, _ = capsys.readouterr()
     cancel_success = "Backup creation was successfully cancelled." in out
@@ -166,7 +184,9 @@ def test_cancel_backup(capsys, instance_id, sample_database):
 @RetryErrors(exception=DeadlineExceeded, max_tries=2)
 def test_create_database_with_retention_period(capsys, sample_instance):
     backup_sample.create_database_with_version_retention_period(
-        sample_instance.instance_id, RETENTION_DATABASE_ID, RETENTION_PERIOD,
+        sample_instance.instance_id,
+        RETENTION_DATABASE_ID,
+        RETENTION_PERIOD,
     )
     out, _ = capsys.readouterr()
     assert (RETENTION_DATABASE_ID + " created with ") in out
diff --git a/samples/samples/batch_sample.py b/samples/samples/batch_sample.py
index 553dc31517..73d9f5667e 100644
--- a/samples/samples/batch_sample.py
+++ b/samples/samples/batch_sample.py
@@ -57,7 +57,7 @@ def run_batch_query(instance_id, database_id):
         for future in concurrent.futures.as_completed(futures, timeout=3600):
             finish, row_ct = future.result()
             elapsed = finish - start
-            print(u"Completed {} rows in {} seconds".format(row_ct, elapsed))
+            print("Completed {} rows in {} seconds".format(row_ct, elapsed))
 
     # Clean up
     snapshot.close()
@@ -68,7 +68,7 @@ def process(snapshot, partition):
     print("Started processing partition.")
     row_ct = 0
     for row in snapshot.process_read_batch(partition):
-        print(u"SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
+        print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
         row_ct += 1
     return time.time(), row_ct
 
diff --git a/samples/samples/conftest.py b/samples/samples/conftest.py
index 314c984920..c745afa151 100644
--- a/samples/samples/conftest.py
+++ b/samples/samples/conftest.py
@@ -31,7 +31,7 @@
 
 @pytest.fixture(scope="module")
 def sample_name():
-    """ Sample testcase modules must define this fixture.
+    """Sample testcase modules must define this fixture.
 
     The name is used to label the instance created by the sample, to
     aid in debugging leaked instances.
@@ -98,7 +98,11 @@ def multi_region_instance_config(spanner_client):
 
 @pytest.fixture(scope="module")
 def sample_instance(
-    spanner_client, cleanup_old_instances, instance_id, instance_config, sample_name,
+    spanner_client,
+    cleanup_old_instances,
+    instance_id,
+    instance_config,
+    sample_name,
 ):
     sample_instance = spanner_client.instance(
         instance_id,
@@ -184,7 +188,8 @@ def database_ddl():
 def sample_database(sample_instance, database_id, database_ddl):
 
     sample_database = sample_instance.database(
-        database_id, ddl_statements=database_ddl,
+        database_id,
+        ddl_statements=database_ddl,
     )
 
     if not sample_database.exists():
diff --git a/samples/samples/snippets.py b/samples/samples/snippets.py
index 3d65ab9c7b..1ada3ad50d 100644
--- a/samples/samples/snippets.py
+++ b/samples/samples/snippets.py
@@ -31,8 +31,8 @@
 from google.cloud import spanner
 from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin
 from google.cloud.spanner_v1 import param_types
+from google.cloud.spanner_v1.data_types import JsonObject
 from google.protobuf import field_mask_pb2  # type: ignore
-
 OPERATION_TIMEOUT_SECONDS = 240
 
 
@@ -351,11 +351,11 @@ def insert_data(instance_id, database_id):
             table="Singers",
             columns=("SingerId", "FirstName", "LastName"),
             values=[
-                (1, u"Marc", u"Richards"),
-                (2, u"Catalina", u"Smith"),
-                (3, u"Alice", u"Trentor"),
-                (4, u"Lea", u"Martin"),
-                (5, u"David", u"Lomond"),
+                (1, "Marc", "Richards"),
+                (2, "Catalina", "Smith"),
+                (3, "Alice", "Trentor"),
+                (4, "Lea", "Martin"),
+                (5, "David", "Lomond"),
             ],
         )
 
@@ -363,11 +363,11 @@ def insert_data(instance_id, database_id):
             table="Albums",
             columns=("SingerId", "AlbumId", "AlbumTitle"),
             values=[
-                (1, 1, u"Total Junk"),
-                (1, 2, u"Go, Go, Go"),
-                (2, 1, u"Green"),
-                (2, 2, u"Forever Hold Your Peace"),
-                (2, 3, u"Terrified"),
+                (1, 1, "Total Junk"),
+                (1, 2, "Go, Go, Go"),
+                (2, 1, "Green"),
+                (2, 2, "Forever Hold Your Peace"),
+                (2, 3, "Terrified"),
             ],
         )
 
@@ -423,7 +423,7 @@ def query_data(instance_id, database_id):
         )
 
         for row in results:
-            print(u"SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
+            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
 
 
 # [END spanner_query_data]
@@ -443,7 +443,7 @@ def read_data(instance_id, database_id):
         )
 
         for row in results:
-            print(u"SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
+            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
 
 
 # [END spanner_read_data]
@@ -469,7 +469,7 @@ def read_stale_data(instance_id, database_id):
         )
 
         for row in results:
-            print(u"SingerId: {}, AlbumId: {}, MarketingBudget: {}".format(*row))
+            print("SingerId: {}, AlbumId: {}, MarketingBudget: {}".format(*row))
 
 
 # [END spanner_read_stale_data]
@@ -495,7 +495,7 @@ def query_data_with_new_column(instance_id, database_id):
         )
 
         for row in results:
-            print(u"SingerId: {}, AlbumId: {}, MarketingBudget: {}".format(*row))
+            print("SingerId: {}, AlbumId: {}, MarketingBudget: {}".format(*row))
 
 
 # [END spanner_query_data_with_new_column]
@@ -560,7 +560,7 @@ def query_data_with_index(
         )
 
         for row in results:
-            print(u"AlbumId: {}, AlbumTitle: {}, " "MarketingBudget: {}".format(*row))
+            print("AlbumId: {}, AlbumTitle: {}, " "MarketingBudget: {}".format(*row))
 
 
 # [END spanner_query_data_with_index]
@@ -647,7 +647,7 @@ def read_data_with_storing_index(instance_id, database_id):
         )
 
         for row in results:
-            print(u"AlbumId: {}, AlbumTitle: {}, " "MarketingBudget: {}".format(*row))
+            print("AlbumId: {}, AlbumTitle: {}, " "MarketingBudget: {}".format(*row))
 
 
 # [END spanner_read_data_with_storing_index]
@@ -789,7 +789,7 @@ def read_only_transaction(instance_id, database_id):
 
         print("Results from first read:")
         for row in results:
-            print(u"SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
+            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
 
         # Perform another read using the `read` method. Even if the data
         # is updated in-between the reads, the snapshot ensures that both
@@ -801,7 +801,7 @@ def read_only_transaction(instance_id, database_id):
 
         print("Results from second read:")
         for row in results:
-            print(u"SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
+            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
 
 
 # [END spanner_read_only_transaction]
@@ -844,7 +844,7 @@ def create_table_with_timestamp(instance_id, database_id):
 
 # [START spanner_insert_data_with_timestamp_column]
 def insert_data_with_timestamp(instance_id, database_id):
-    """Inserts data with a COMMIT_TIMESTAMP field into a table. """
+    """Inserts data with a COMMIT_TIMESTAMP field into a table."""
 
     spanner_client = spanner.Client()
     instance = spanner_client.instance(instance_id)
@@ -870,8 +870,7 @@ def insert_data_with_timestamp(instance_id, database_id):
 
 # [START spanner_add_timestamp_column]
 def add_timestamp_column(instance_id, database_id):
-    """ Adds a new TIMESTAMP column to the Albums table in the example database.
-    """
+    """Adds a new TIMESTAMP column to the Albums table in the example database."""
     spanner_client = spanner.Client()
     instance = spanner_client.instance(instance_id)
 
@@ -960,7 +959,7 @@ def query_data_with_timestamp(instance_id, database_id):
         )
 
     for row in results:
-        print(u"SingerId: {}, AlbumId: {}, MarketingBudget: {}".format(*row))
+        print("SingerId: {}, AlbumId: {}, MarketingBudget: {}".format(*row))
 
 
 # [END spanner_query_data_with_timestamp_column]
@@ -968,8 +967,7 @@ def query_data_with_timestamp(instance_id, database_id):
 
 # [START spanner_add_numeric_column]
 def add_numeric_column(instance_id, database_id):
-    """ Adds a new NUMERIC column to the Venues table in the example database.
-    """
+    """Adds a new NUMERIC column to the Venues table in the example database."""
     spanner_client = spanner.Client()
     instance = spanner_client.instance(instance_id)
 
@@ -1026,8 +1024,7 @@ def update_data_with_numeric(instance_id, database_id):
 
 # [START spanner_add_json_column]
 def add_json_column(instance_id, database_id):
-    """ Adds a new JSON column to the Venues table in the example database.
-    """
+    """Adds a new JSON column to the Venues table in the example database."""
     spanner_client = spanner.Client()
     instance = spanner_client.instance(instance_id)
 
@@ -1072,17 +1069,17 @@ def update_data_with_json(instance_id, database_id):
             values=[
                 (
                     4,
-                    json.dumps(
+                    JsonObject(
                         [
-                            {"name": "room 1", "open": True},
-                            {"name": "room 2", "open": False},
+                            JsonObject({"name": "room 1", "open": True}),
+                            JsonObject({"name": "room 2", "open": False}),
                         ]
                     ),
                 ),
-                (19, json.dumps({"rating": 9, "open": True})),
+                (19, JsonObject(rating=9, open=True)),
                 (
                     42,
-                    json.dumps(
+                    JsonObject(
                         {
                             "name": None,
                             "open": {"Monday": True, "Tuesday": False},
@@ -1113,10 +1110,10 @@ def write_struct_data(instance_id, database_id):
             table="Singers",
             columns=("SingerId", "FirstName", "LastName"),
             values=[
-                (6, u"Elena", u"Campbell"),
-                (7, u"Gabriel", u"Wright"),
-                (8, u"Benjamin", u"Martinez"),
-                (9, u"Hannah", u"Harris"),
+                (6, "Elena", "Campbell"),
+                (7, "Gabriel", "Wright"),
+                (8, "Benjamin", "Martinez"),
+                (9, "Hannah", "Harris"),
             ],
         )
 
@@ -1127,7 +1124,7 @@ def write_struct_data(instance_id, database_id):
 
 
 def query_with_struct(instance_id, database_id):
-    """Query a table using STRUCT parameters. """
+    """Query a table using STRUCT parameters."""
     # [START spanner_create_struct_with_data]
     record_type = param_types.Struct(
         [
@@ -1152,12 +1149,12 @@ def query_with_struct(instance_id, database_id):
         )
 
     for row in results:
-        print(u"SingerId: {}".format(*row))
+        print("SingerId: {}".format(*row))
     # [END spanner_query_data_with_struct]
 
 
 def query_with_array_of_struct(instance_id, database_id):
-    """Query a table using an array of STRUCT parameters. """
+    """Query a table using an array of STRUCT parameters."""
     # [START spanner_create_user_defined_struct]
     name_type = param_types.Struct(
         [
@@ -1190,13 +1187,13 @@ def query_with_array_of_struct(instance_id, database_id):
         )
 
     for row in results:
-        print(u"SingerId: {}".format(*row))
+        print("SingerId: {}".format(*row))
     # [END spanner_query_data_with_array_of_struct]
 
 
 # [START spanner_field_access_on_struct_parameters]
 def query_struct_field(instance_id, database_id):
-    """Query a table using field access on a STRUCT parameter. """
+    """Query a table using field access on a STRUCT parameter."""
     spanner_client = spanner.Client()
     instance = spanner_client.instance(instance_id)
     database = instance.database(database_id)
@@ -1216,7 +1213,7 @@ def query_struct_field(instance_id, database_id):
         )
 
     for row in results:
-        print(u"SingerId: {}".format(*row))
+        print("SingerId: {}".format(*row))
 
 
 # [END spanner_field_access_on_struct_parameters]
@@ -1224,7 +1221,7 @@ def query_struct_field(instance_id, database_id):
 
 # [START spanner_field_access_on_nested_struct_parameters]
 def query_nested_struct_field(instance_id, database_id):
-    """Query a table using nested field access on a STRUCT parameter. """
+    """Query a table using nested field access on a STRUCT parameter."""
     spanner_client = spanner.Client()
     instance = spanner_client.instance(instance_id)
     database = instance.database(database_id)
@@ -1260,14 +1257,14 @@ def query_nested_struct_field(instance_id, database_id):
         )
 
     for row in results:
-        print(u"SingerId: {} SongName: {}".format(*row))
+        print("SingerId: {} SongName: {}".format(*row))
 
 
 # [END spanner_field_access_on_nested_struct_parameters]
 
 
 def insert_data_with_dml(instance_id, database_id):
-    """Inserts sample data into the given database using a DML statement. """
+    """Inserts sample data into the given database using a DML statement."""
     # [START spanner_dml_standard_insert]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1290,7 +1287,7 @@ def insert_singers(transaction):
 
 # [START spanner_get_commit_stats]
 def log_commit_stats(instance_id, database_id):
-    """Inserts sample data using DML and displays the commit statistics. """
+    """Inserts sample data using DML and displays the commit statistics."""
     # By default, commit statistics are logged via stdout at level Info.
     # This sample uses a custom logger to access the commit statistics.
     class CommitStatsSampleLogger(logging.Logger):
@@ -1325,7 +1322,7 @@ def insert_singers(transaction):
 
 
 def update_data_with_dml(instance_id, database_id):
-    """Updates sample data from the database using a DML statement. """
+    """Updates sample data from the database using a DML statement."""
     # [START spanner_dml_standard_update]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1348,7 +1345,7 @@ def update_albums(transaction):
 
 
 def delete_data_with_dml(instance_id, database_id):
-    """Deletes sample data from the database using a DML statement. """
+    """Deletes sample data from the database using a DML statement."""
     # [START spanner_dml_standard_delete]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1369,7 +1366,7 @@ def delete_singers(transaction):
 
 
 def update_data_with_dml_timestamp(instance_id, database_id):
-    """Updates data with Timestamp from the database using a DML statement. """
+    """Updates data with Timestamp from the database using a DML statement."""
     # [START spanner_dml_standard_update_with_timestamp]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1421,7 +1418,7 @@ def write_then_read(transaction):
 
 
 def update_data_with_dml_struct(instance_id, database_id):
-    """Updates data with a DML statement and STRUCT parameters. """
+    """Updates data with a DML statement and STRUCT parameters."""
     # [START spanner_dml_structs]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1453,7 +1450,7 @@ def write_with_struct(transaction):
 
 
 def insert_with_dml(instance_id, database_id):
-    """Inserts data with a DML statement into the database. """
+    """Inserts data with a DML statement into the database."""
     # [START spanner_dml_getting_started_insert]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1493,12 +1490,12 @@ def query_data_with_parameter(instance_id, database_id):
         )
 
         for row in results:
-            print(u"SingerId: {}, FirstName: {}, LastName: {}".format(*row))
+            print("SingerId: {}, FirstName: {}, LastName: {}".format(*row))
     # [END spanner_query_with_parameter]
 
 
 def write_with_dml_transaction(instance_id, database_id):
-    """ Transfers part of a marketing budget from one album to another. """
+    """Transfers part of a marketing budget from one album to another."""
     # [START spanner_dml_getting_started_update]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1561,7 +1558,7 @@ def transfer_budget(transaction):
 
 
 def update_data_with_partitioned_dml(instance_id, database_id):
-    """ Update sample data with a partitioned DML statement. """
+    """Update sample data with a partitioned DML statement."""
     # [START spanner_dml_partitioned_update]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1579,7 +1576,7 @@ def update_data_with_partitioned_dml(instance_id, database_id):
 
 
 def delete_data_with_partitioned_dml(instance_id, database_id):
-    """ Delete sample data with a partitioned DML statement. """
+    """Delete sample data with a partitioned DML statement."""
     # [START spanner_dml_partitioned_delete]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1594,7 +1591,7 @@ def delete_data_with_partitioned_dml(instance_id, database_id):
 
 
 def update_with_batch_dml(instance_id, database_id):
-    """Updates sample data in the database using Batch DML. """
+    """Updates sample data in the database using Batch DML."""
     # [START spanner_dml_batch_update]
     from google.rpc.code_pb2 import OK
 
@@ -1633,7 +1630,7 @@ def update_albums(transaction):
 
 
 def create_table_with_datatypes(instance_id, database_id):
-    """Creates a table with supported dataypes. """
+    """Creates a table with supported dataypes."""
     # [START spanner_create_table_with_datatypes]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1670,7 +1667,7 @@ def create_table_with_datatypes(instance_id, database_id):
 
 
 def insert_datatypes_data(instance_id, database_id):
-    """Inserts data with supported datatypes into a table. """
+    """Inserts data with supported datatypes into a table."""
     # [START spanner_insert_datatypes_data]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1678,9 +1675,9 @@ def insert_datatypes_data(instance_id, database_id):
     instance = spanner_client.instance(instance_id)
     database = instance.database(database_id)
 
-    exampleBytes1 = base64.b64encode(u"Hello World 1".encode())
-    exampleBytes2 = base64.b64encode(u"Hello World 2".encode())
-    exampleBytes3 = base64.b64encode(u"Hello World 3".encode())
+    exampleBytes1 = base64.b64encode("Hello World 1".encode())
+    exampleBytes2 = base64.b64encode("Hello World 2".encode())
+    exampleBytes3 = base64.b64encode("Hello World 3".encode())
     available_dates1 = ["2020-12-01", "2020-12-02", "2020-12-03"]
     available_dates2 = ["2020-11-01", "2020-11-05", "2020-11-15"]
     available_dates3 = ["2020-10-01", "2020-10-07"]
@@ -1701,7 +1698,7 @@ def insert_datatypes_data(instance_id, database_id):
             values=[
                 (
                     4,
-                    u"Venue 4",
+                    "Venue 4",
                     exampleBytes1,
                     1800,
                     available_dates1,
@@ -1712,7 +1709,7 @@ def insert_datatypes_data(instance_id, database_id):
                 ),
                 (
                     19,
-                    u"Venue 19",
+                    "Venue 19",
                     exampleBytes2,
                     6300,
                     available_dates2,
@@ -1723,7 +1720,7 @@ def insert_datatypes_data(instance_id, database_id):
                 ),
                 (
                     42,
-                    u"Venue 42",
+                    "Venue 42",
                     exampleBytes3,
                     3000,
                     available_dates3,
@@ -1740,7 +1737,7 @@ def insert_datatypes_data(instance_id, database_id):
 
 
 def query_data_with_array(instance_id, database_id):
-    """Queries sample data using SQL with an ARRAY parameter. """
+    """Queries sample data using SQL with an ARRAY parameter."""
     # [START spanner_query_with_array_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1762,12 +1759,12 @@ def query_data_with_array(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}, AvailableDate: {}".format(*row))
+            print("VenueId: {}, VenueName: {}, AvailableDate: {}".format(*row))
     # [END spanner_query_with_array_parameter]
 
 
 def query_data_with_bool(instance_id, database_id):
-    """Queries sample data using SQL with a BOOL parameter. """
+    """Queries sample data using SQL with a BOOL parameter."""
     # [START spanner_query_with_bool_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1788,12 +1785,12 @@ def query_data_with_bool(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}, OutdoorVenue: {}".format(*row))
+            print("VenueId: {}, VenueName: {}, OutdoorVenue: {}".format(*row))
     # [END spanner_query_with_bool_parameter]
 
 
 def query_data_with_bytes(instance_id, database_id):
-    """Queries sample data using SQL with a BYTES parameter. """
+    """Queries sample data using SQL with a BYTES parameter."""
     # [START spanner_query_with_bytes_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1801,7 +1798,7 @@ def query_data_with_bytes(instance_id, database_id):
     instance = spanner_client.instance(instance_id)
     database = instance.database(database_id)
 
-    exampleBytes = base64.b64encode(u"Hello World 1".encode())
+    exampleBytes = base64.b64encode("Hello World 1".encode())
     param = {"venue_info": exampleBytes}
     param_type = {"venue_info": param_types.BYTES}
 
@@ -1813,12 +1810,12 @@ def query_data_with_bytes(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}".format(*row))
+            print("VenueId: {}, VenueName: {}".format(*row))
     # [END spanner_query_with_bytes_parameter]
 
 
 def query_data_with_date(instance_id, database_id):
-    """Queries sample data using SQL with a DATE parameter. """
+    """Queries sample data using SQL with a DATE parameter."""
     # [START spanner_query_with_date_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1839,12 +1836,12 @@ def query_data_with_date(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}, LastContactDate: {}".format(*row))
+            print("VenueId: {}, VenueName: {}, LastContactDate: {}".format(*row))
     # [END spanner_query_with_date_parameter]
 
 
 def query_data_with_float(instance_id, database_id):
-    """Queries sample data using SQL with a FLOAT64 parameter. """
+    """Queries sample data using SQL with a FLOAT64 parameter."""
     # [START spanner_query_with_float_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1865,12 +1862,12 @@ def query_data_with_float(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}, PopularityScore: {}".format(*row))
+            print("VenueId: {}, VenueName: {}, PopularityScore: {}".format(*row))
     # [END spanner_query_with_float_parameter]
 
 
 def query_data_with_int(instance_id, database_id):
-    """Queries sample data using SQL with a INT64 parameter. """
+    """Queries sample data using SQL with a INT64 parameter."""
     # [START spanner_query_with_int_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1891,12 +1888,12 @@ def query_data_with_int(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}, Capacity: {}".format(*row))
+            print("VenueId: {}, VenueName: {}, Capacity: {}".format(*row))
     # [END spanner_query_with_int_parameter]
 
 
 def query_data_with_string(instance_id, database_id):
-    """Queries sample data using SQL with a STRING parameter. """
+    """Queries sample data using SQL with a STRING parameter."""
     # [START spanner_query_with_string_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1916,12 +1913,12 @@ def query_data_with_string(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}".format(*row))
+            print("VenueId: {}, VenueName: {}".format(*row))
     # [END spanner_query_with_string_parameter]
 
 
 def query_data_with_numeric_parameter(instance_id, database_id):
-    """Queries sample data using SQL with a NUMERIC parameter. """
+    """Queries sample data using SQL with a NUMERIC parameter."""
     # [START spanner_query_with_numeric_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1941,12 +1938,12 @@ def query_data_with_numeric_parameter(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, Revenue: {}".format(*row))
+            print("VenueId: {}, Revenue: {}".format(*row))
     # [END spanner_query_with_numeric_parameter]
 
 
 def query_data_with_json_parameter(instance_id, database_id):
-    """Queries sample data using SQL with a JSON parameter. """
+    """Queries sample data using SQL with a JSON parameter."""
     # [START spanner_query_with_json_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -1969,12 +1966,12 @@ def query_data_with_json_parameter(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueDetails: {}".format(*row))
+            print("VenueId: {}, VenueDetails: {}".format(*row))
     # [END spanner_query_with_json_parameter]
 
 
 def query_data_with_timestamp_parameter(instance_id, database_id):
-    """Queries sample data using SQL with a TIMESTAMP parameter. """
+    """Queries sample data using SQL with a TIMESTAMP parameter."""
     # [START spanner_query_with_timestamp_parameter]
     # instance_id = "your-spanner-instance"
     # database_id = "your-spanner-db-id"
@@ -2002,7 +1999,7 @@ def query_data_with_timestamp_parameter(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}, LastUpdateTime: {}".format(*row))
+            print("VenueId: {}, VenueName: {}, LastUpdateTime: {}".format(*row))
     # [END spanner_query_with_timestamp_parameter]
 
 
@@ -2025,7 +2022,7 @@ def query_data_with_query_options(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}, LastUpdateTime: {}".format(*row))
+            print("VenueId: {}, VenueName: {}, LastUpdateTime: {}".format(*row))
     # [END spanner_query_with_query_options]
 
 
@@ -2049,7 +2046,7 @@ def create_client_with_query_options(instance_id, database_id):
         )
 
         for row in results:
-            print(u"VenueId: {}, VenueName: {}, LastUpdateTime: {}".format(*row))
+            print("VenueId: {}, VenueName: {}, LastUpdateTime: {}".format(*row))
     # [END spanner_create_client_with_query_options]
 
 
@@ -2113,7 +2110,7 @@ def set_request_tag(instance_id, database_id):
         )
 
         for row in results:
-            print(u"SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
+            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))
 
     # [END spanner_set_request_tag]
 
diff --git a/samples/samples/snippets_test.py b/samples/samples/snippets_test.py
index f085a0e71c..0f36e81728 100644
--- a/samples/samples/snippets_test.py
+++ b/samples/samples/snippets_test.py
@@ -128,7 +128,8 @@ def test_create_database_explicit(sample_instance, create_database_id):
 def test_create_instance_with_processing_units(capsys, lci_instance_id):
     processing_units = 500
     retry_429(snippets.create_instance_with_processing_units)(
-        lci_instance_id, processing_units,
+        lci_instance_id,
+        processing_units,
     )
     out, _ = capsys.readouterr()
     assert lci_instance_id in out
@@ -543,7 +544,8 @@ def test_create_table_with_datatypes(capsys, instance_id, sample_database):
 
 
 @pytest.mark.dependency(
-    name="insert_datatypes_data", depends=["create_table_with_datatypes"],
+    name="insert_datatypes_data",
+    depends=["create_table_with_datatypes"],
 )
 def test_insert_datatypes_data(capsys, instance_id, sample_database):
     snippets.insert_datatypes_data(instance_id, sample_database.database_id)
@@ -605,7 +607,8 @@ def test_query_data_with_string(capsys, instance_id, sample_database):
 
 
 @pytest.mark.dependency(
-    name="add_numeric_column", depends=["create_table_with_datatypes"],
+    name="add_numeric_column",
+    depends=["create_table_with_datatypes"],
 )
 def test_add_numeric_column(capsys, instance_id, sample_database):
     snippets.add_numeric_column(instance_id, sample_database.database_id)
@@ -628,7 +631,8 @@ def test_query_data_with_numeric_parameter(capsys, instance_id, sample_database)
 
 
 @pytest.mark.dependency(
-    name="add_json_column", depends=["create_table_with_datatypes"],
+    name="add_json_column",
+    depends=["create_table_with_datatypes"],
 )
 def test_add_json_column(capsys, instance_id, sample_database):
     snippets.add_json_column(instance_id, sample_database.database_id)