spanner-integration.yaml

# Copyright 2026 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.
description: Integrate Google Cloud Logging Spanner Handwritten code
url: https://github.com/googleapis/gapic-generator-python/issues/123
replacements:
  - paths: [packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/client.py]
    before: '(import google\.rpc\.status_pb2 as status_pb2  # type: ignore\n\n)(?!from google\.cloud\.spanner_v1\.metrics)'
    after: |
      \g<1>from google.cloud.spanner_v1.metrics.metrics_interceptor import MetricsInterceptor
    count: 1

  - paths: [packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/client.py]
    before: '(\s+api_audience=self\._client_options\.api_audience,\n)(?!\s+metrics_interceptor=MetricsInterceptor)'
    after: |
      \g<1>                metrics_interceptor=MetricsInterceptor(),
    count: 1

  - paths: [packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/base.py]
    before: '(from google\.cloud\.spanner_v1 import gapic_version as package_version\n)(?!from google\.cloud\.spanner_v1\.metrics)'
    after: |
      \g<1>from google.cloud.spanner_v1.metrics.metrics_interceptor import MetricsInterceptor
    count: 1

  - paths: [packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/rest.py]
    before: '(from requests import __version__ as requests_version\n\n)(?!from google\.cloud\.spanner_v1\.metrics)'
    after: |
      \g<1>from google.cloud.spanner_v1.metrics.metrics_interceptor import MetricsInterceptor
    count: 1
  
  - paths: [packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/grpc_asyncio.py]
    before: '(from grpc\.experimental import aio  # type: ignore\n\n)(?!from google\.cloud\.spanner_v1\.metrics)'
    after: |
      \g<1>from google.cloud.spanner_v1.metrics.metrics_interceptor import MetricsInterceptor
    count: 1
  
  - paths: [packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/grpc.py]
    before: '(from google\.protobuf\.json_format import MessageToJson\n\n)(?!from google\.cloud\.spanner_v1\.metrics)'
    after: |
      \g<1>from google.cloud.spanner_v1.metrics.metrics_interceptor import MetricsInterceptor
    count: 1
  
  - paths: [packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/rest_base.py]
    before: '(from google\.protobuf import json_format\n\n)(?!from google\.cloud\.spanner_v1\.metrics)'
    after: |
      \g<1>from google.cloud.spanner_v1.metrics.metrics_interceptor import MetricsInterceptor
    count: 1

  - paths:
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/base.py
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/grpc.py
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/grpc_asyncio.py
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/rest.py
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/rest_base.py
    before: '(\s+api_audience: Optional\[str\] = None,\n)(?!\s+metrics_interceptor: Optional\[MetricsInterceptor\])'
    after: |
      \g<1>        metrics_interceptor: Optional[MetricsInterceptor] = None,
    count: 5

  - paths: 
      # Source Transports
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/grpc.py
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/grpc_asyncio.py
      - packages/google-cloud-spanner/google/cloud/spanner_admin_database_v1/services/database_admin/transports/grpc.py
      - packages/google-cloud-spanner/google/cloud/spanner_admin_database_v1/services/database_admin/transports/grpc_asyncio.py
      - packages/google-cloud-spanner/google/cloud/spanner_admin_instance_v1/services/instance_admin/transports/grpc.py
      - packages/google-cloud-spanner/google/cloud/spanner_admin_instance_v1/services/instance_admin/transports/grpc_asyncio.py
      # Test Files
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_admin_database_v1/test_database_admin.py
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_admin_instance_v1/test_instance_admin.py
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_v1/test_spanner.py
    # Group 1 captures exactly the spaces/tabs on that line.
    # Group 2 captures the code up to the newline.
    before: '([ \t]+)(\("grpc\.max_receive_message_length", -1\),\n)(?![ \t]+\("grpc\.keepalive_time_ms")'
    after: |
      \g<1>\g<2>\g<1>("grpc.keepalive_time_ms", 120000),
    count: 21

  - paths: 
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_v1/test_spanner.py
    before: '(\s+api_audience=\"https\:\/\/language\.googleapis\.com\",\n)(?!\s+metrics_interceptor=mock\.ANY,)'
    after: |
      \g<1>            metrics_interceptor=mock.ANY,
    count: 1
    # Temporary patch until gapic-generator 1.38 or newer is released.
    # From https://github.com/googleapis/google-cloud-python/pull/17838
  - paths:
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_admin_database_v1/test_database_admin.py
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_admin_instance_v1/test_instance_admin.py
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_v1/test_spanner.py
    before: |
      for config_data, expected_cert_source in test_cases:
      \            env = os.environ.copy\(\)
      \            env.pop\("GOOGLE_API_USE_CLIENT_CERTIFICATE", None\)
      \            with mock.patch.dict\(os.environ, env, clear=True\):
    after: |
      for config_data, expected_cert_source in test_cases:
                env = os.environ.copy()
                env.pop("GOOGLE_API_USE_CLIENT_CERTIFICATE", None)
                env.pop("CLOUDSDK_CONTEXT_AWARE_USE_CLIENT_CERTIFICATE", None)
                with mock.patch.dict(os.environ, env, clear=True):
    count: 3
    # Temporary patch until gapic-generator 1.38 or newer is released.
    # From https://github.com/googleapis/google-cloud-python/pull/17838
  - paths:
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_admin_database_v1/test_database_admin.py
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_admin_instance_v1/test_instance_admin.py
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_v1/test_spanner.py
    before: |
      for config_data, expected_cert_source in test_cases:
      \            env = os.environ.copy\(\)
      \            env.pop\("GOOGLE_API_USE_CLIENT_CERTIFICATE", ""\)
      \            with mock.patch.dict\(os.environ, env, clear=True\):
    after: |
      for config_data, expected_cert_source in test_cases:
                env = os.environ.copy()
                env.pop("GOOGLE_API_USE_CLIENT_CERTIFICATE", "")
                env.pop("CLOUDSDK_CONTEXT_AWARE_USE_CLIENT_CERTIFICATE", "")
                with mock.patch.dict(os.environ, env, clear=True):
    count: 3
  - paths: 
      - packages/google-cloud-spanner/tests/unit/gapic/spanner_v1/test_spanner.py
    # Group 1: Captures ONLY the spaces/tabs before the text
    # Group 2: Captures the text itself and the newline
    before: '([ \t]+)(api_audience=None,\n)(?![ \t]+metrics_interceptor=mock\.ANY,)'
    after: |
      \g<1>\g<2>\g<1>metrics_interceptor=mock.ANY,
    count: 12

  - paths:
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/grpc.py
    before: '(\s+self\._stubs: Dict\[str, Callable\] = \{\}\n)(?!\s+self\._metrics_interceptor = None)'
    after: |
      \g<1>        self._metrics_interceptor = None
    count: 1
  - paths: 
      - packages/google-cloud-spanner/google/cloud/spanner_v1/services/spanner/transports/grpc.py
    before: '([ \t]+)(\("grpc\.keepalive_time_ms", 120000\),\n[ \t]+\](?:,\n[ \t]*|\n[ \t]*)\)\n+)([ \t]+)(self\._interceptor = _LoggingClientInterceptor\(\)\n)'
    after: |
      \g<1>\g<2>\g<3># Wrap the gRPC channel with the metric interceptor
      \g<3>if metrics_interceptor is not None:
      \g<3>    self._metrics_interceptor = metrics_interceptor
      \g<3>    self._grpc_channel = grpc.intercept_channel(
      \g<3>        self._grpc_channel, metrics_interceptor
      \g<3>    )

      \g<3>\g<4>
    count: 1
  - paths: [packages/google-cloud-spanner/setup.py]
    before: '(?s)dependencies = \[.*?\]\nextras = \{\s*\}'
    after: |
      dependencies = [
          "google-api-core[grpc] >= 2.25.0, <3.0.0",
          # Exclude incompatible versions of `google-auth`
          # See https://github.com/googleapis/google-cloud-python/issues/12364
          "google-auth >= 2.14.1, <3.0.0,!=2.24.0,!=2.25.0",
          "google-cloud-core >= 2.0.0, < 3.0.0",
          "grpcio >= 1.59.0, < 2.0.0",
          "grpcio >= 1.75.1, < 2.0.0; python_version >= '3.14'",
          "grpc-google-iam-v1 >= 0.14.2, <1.0.0",
          "proto-plus >= 1.26.1, <2.0.0",
          "protobuf >= 6.33.5, < 8.0.0",
          "grpc-interceptor >= 0.15.4",
          "sqlparse >= 0.4.4",
          # Make OpenTelemetry a core dependency
          "opentelemetry-api >= 1.22.0",
          "opentelemetry-sdk >= 1.22.0",
          "opentelemetry-semantic-conventions >= 0.43b0",
          "opentelemetry-resourcedetector-gcp >= 1.8.0a0",
          "google-cloud-monitoring >= 2.28.0",
          "mmh3 >= 4.1.0",
      ]
      extras = {
          "libcst": "libcst >= 0.2.5",
          "test": [
              "pytest",
              "mock",
              "asyncmock",
              "pytest-cov",
              "pytest-asyncio",
              "pytest-xdist",
          ],
      }
    count: 1
  - paths: [packages/google-cloud-spanner/docs/index.rst]
    before: '(?s)API Reference\n-------------.*'
    after: |
      Usage Documentation
      -------------------
      .. toctree::
        :maxdepth: 2

        client-usage
        table-usage
        batch-usage
        snapshot-usage
        transaction-usage

        database-usage
        instance-usage

      API Documentation
      -----------------
      .. toctree::
        :maxdepth: 1
        :titlesonly:

        advanced-session-pool-topics
        opentelemetry-tracing

        spanner_v1/client
        spanner_v1/instance
        spanner_v1/database
        spanner_v1/table
        spanner_v1/session
        spanner_v1/keyset
        spanner_v1/snapshot
        spanner_v1/batch
        spanner_v1/transaction
        spanner_v1/streamed

        spanner_v1/services_
        spanner_v1/types_
        spanner_admin_database_v1/services_
        spanner_admin_database_v1/types_
        spanner_admin_database_v1/database_admin
        spanner_admin_instance_v1/services_
        spanner_admin_instance_v1/types_
        spanner_admin_instance_v1/instance_admin
      


      Changelog
      ---------

      For a list of all ``google-cloud-spanner`` releases:

      .. toctree::
        :maxdepth: 2

        CHANGELOG

      .. toctree::
        :hidden:

        summary_overview.md
    count: 1
  - paths: [packages/google-cloud-spanner/google/cloud/spanner_v1/__init__.py]
    before: '(?s)import sys\n\nimport google\.api_core as api_core.*'
    after: |
      from __future__ import absolute_import

      from google.cloud.spanner_v1 import gapic_version as package_version

      __version__: str = package_version.__version__

      from google.cloud.spanner_v1 import param_types
      from google.cloud.spanner_v1._async.client import Client as AsyncClient
      from google.cloud.spanner_v1._async.pool import (
          AbstractSessionPool as AsyncAbstractSessionPool,
      )
      from google.cloud.spanner_v1._async.pool import BurstyPool as AsyncBurstyPool
      from google.cloud.spanner_v1._async.pool import FixedSizePool as AsyncFixedSizePool
      from google.cloud.spanner_v1._async.pool import PingingPool as AsyncPingingPool
      from google.cloud.spanner_v1._async.pool import (
          TransactionPingingPool as AsyncTransactionPingingPool,
      )
      from google.cloud.spanner_v1.client import Client
      from google.cloud.spanner_v1.keyset import KeyRange, KeySet
      from google.cloud.spanner_v1.pool import (
          AbstractSessionPool,
          BurstyPool,
          FixedSizePool,
          PingingPool,
          TransactionPingingPool,
      )

      from .data_types import Interval, JsonObject
      from .exceptions import wrap_with_request_id
      from .services.spanner import SpannerAsyncClient, SpannerClient
      from .transaction import BatchTransactionId, DefaultTransactionOptions
      from .types import RequestOptions
      from .types.commit_response import CommitResponse
      from .types.keys import KeyRange as KeyRangePB
      from .types.keys import KeySet as KeySetPB
      from .types.mutation import Mutation
      from .types.query_plan import PlanNode, QueryPlan
      from .types.result_set import (
          PartialResultSet,
          ResultSet,
          ResultSetMetadata,
          ResultSetStats,
      )
      from .types.spanner import (
          BatchCreateSessionsRequest,
          BatchCreateSessionsResponse,
          BatchWriteRequest,
          BatchWriteResponse,
          BeginTransactionRequest,
          CommitRequest,
          CreateSessionRequest,
          DeleteSessionRequest,
          DirectedReadOptions,
          ExecuteBatchDmlRequest,
          ExecuteBatchDmlResponse,
          ExecuteSqlRequest,
          GetSessionRequest,
          ListSessionsRequest,
          ListSessionsResponse,
          Partition,
          PartitionOptions,
          PartitionQueryRequest,
          PartitionReadRequest,
          PartitionResponse,
          ReadRequest,
          RollbackRequest,
          Session,
      )
      from .types.transaction import Transaction, TransactionOptions, TransactionSelector
      from .types.type import StructType, Type, TypeAnnotationCode, TypeCode

      COMMIT_TIMESTAMP = "spanner.commit_timestamp()"
      """Placeholder be used to store commit timestamp of a transaction in a column.
      This value can only be used for timestamp columns that have set the option
      ``(allow_commit_timestamp=true)`` in the schema.
      """

      __all__ = (
          # google.cloud.spanner_v1
          "__version__",
          "param_types",
          # google.cloud.spanner_v1.exceptions
          "wrap_with_request_id",
          # google.cloud.spanner_v1.client
          "Client",
          "AsyncClient",
          # google.cloud.spanner_v1.keyset
          "KeyRange",
          "KeySet",
          # google.cloud.spanner_v1.pool
          "AbstractSessionPool",
          "BurstyPool",
          "FixedSizePool",
          "PingingPool",
          "TransactionPingingPool",
          "AsyncAbstractSessionPool",
          "AsyncBurstyPool",
          "AsyncFixedSizePool",
          "AsyncPingingPool",
          "AsyncTransactionPingingPool",
          # local
          "COMMIT_TIMESTAMP",
          # google.cloud.spanner_v1.types
          "BatchCreateSessionsRequest",
          "BatchCreateSessionsResponse",
          "BatchWriteRequest",
          "BatchWriteResponse",
          "BeginTransactionRequest",
          "CommitRequest",
          "CommitResponse",
          "CreateSessionRequest",
          "DeleteSessionRequest",
          "DirectedReadOptions",
          "ExecuteBatchDmlRequest",
          "ExecuteBatchDmlResponse",
          "ExecuteSqlRequest",
          "GetSessionRequest",
          "KeyRangePB",
          "KeySetPB",
          "ListSessionsRequest",
          "ListSessionsResponse",
          "Mutation",
          "PartialResultSet",
          "Partition",
          "PartitionOptions",
          "PartitionQueryRequest",
          "PartitionReadRequest",
          "PartitionResponse",
          "PlanNode",
          "QueryPlan",
          "ReadRequest",
          "RequestOptions",
          "ResultSet",
          "ResultSetMetadata",
          "ResultSetStats",
          "RollbackRequest",
          "Session",
          "StructType",
          "Transaction",
          "TransactionOptions",
          "TransactionSelector",
          "Type",
          "TypeAnnotationCode",
          "TypeCode",
          # Custom spanner related data types
          "JsonObject",
          "Interval",
          # google.cloud.spanner_v1.services
          "SpannerClient",
          "SpannerAsyncClient",
          "BatchTransactionId",
          "DefaultTransactionOptions",
      )
    count: 1
  - paths: [packages/google-cloud-spanner/google/cloud/spanner/__init__.py]
    before: '(?s)from google.cloud.spanner import gapic_version as package_version.*'
    after: |
      from __future__ import absolute_import

      from google.cloud.spanner_v1 import (
          COMMIT_TIMESTAMP,
          AbstractSessionPool,
          BurstyPool,
          Client,
          FixedSizePool,
          KeyRange,
          KeySet,
          PingingPool,
          TransactionPingingPool,
          __version__,
          param_types,
      )

      __all__ = (
          # google.cloud.spanner
          "__version__",
          "param_types",
          # google.cloud.spanner_v1.client
          "Client",
          # google.cloud.spanner_v1.keyset
          "KeyRange",
          "KeySet",
          # google.cloud.spanner_v1.pool
          "AbstractSessionPool",
          "BurstyPool",
          "FixedSizePool",
          "PingingPool",
          "TransactionPingingPool",
          # local
          "COMMIT_TIMESTAMP",
      )
    count: 1
  - paths: [
      packages/google-cloud-spanner/README.rst
    ]
    before: |
      Windows
      \^\^\^\^\^\^\^
      [\s\S]*?pip install google-cloud-spanner\n\nNext Steps
    after: |
      Windows
      ^^^^^^^

      .. code-block:: console

          py -m venv <your-env>
          .\\<your-env>\\Scripts\\activate
          pip install google-cloud-spanner


      Example Usage
      -------------


      Executing Arbitrary SQL in a Transaction
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      Generally, to work with Cloud Spanner, you will want a transaction. The
      preferred mechanism for this is to create a single function, which executes
      as a callback to ``database.run_in_transaction``:

      .. code:: python

          # First, define the function that represents a single "unit of work"
          # that should be run within the transaction.
          def update_anniversary(transaction, person_id, unix_timestamp):
              # The query itself is just a string.
              #
              # The use of @parameters is recommended rather than doing your
              # own string interpolation; this provides protections against
              # SQL injection attacks.
              query = """SELECT anniversary FROM people
                  WHERE id = @person_id"""

              # When executing the SQL statement, the query and parameters are sent
              # as separate arguments. When using parameters, you must specify
              # both the parameters themselves and their types.
              row = transaction.execute_sql(
                  query=query,
                  params={'person_id': person_id},
                  param_types={
                      'person_id': types.INT64_PARAM_TYPE,
                  },
              ).one()

              # Now perform an update on the data.
              old_anniversary = row[0]
              new_anniversary = _compute_anniversary(old_anniversary, years)
              transaction.update(
                  'people',
                  ['person_id', 'anniversary'],
                  [person_id, new_anniversary],
              )

          # Actually run the `update_anniversary` function in a transaction.
          database.run_in_transaction(update_anniversary,
              person_id=42,
              unix_timestamp=1335020400,
          )


      Select records using a Transaction
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      Once you have a transaction object (such as the first argument sent to
      ``run_in_transaction``), reading data is easy:

      .. code:: python

          # Define a SELECT query.
          query = """SELECT e.first_name, e.last_name, p.telephone
              FROM employees as e, phones as p
              WHERE p.employee_id == e.employee_id"""

          # Execute the query and return results.
          result = transaction.execute_sql(query)
          for row in result.rows:
              print(row)


      Insert records using Data Manipulation Language (DML) with a Transaction
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      Use the ``execute_update()`` method to execute a DML statement:

      .. code:: python

          spanner_client = spanner.Client()
          instance = spanner_client.instance(instance_id)
          database = instance.database(database_id)

          def insert_singers(transaction):
              row_ct = transaction.execute_update(
                  "INSERT Singers (SingerId, FirstName, LastName) "
                  " VALUES (10, 'Virginia', 'Watson')"
              )

              print("{} record(s) inserted.".format(row_ct))

          database.run_in_transaction(insert_singers)


      Insert records using Mutations with a Transaction
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      To add one or more records to a table, use ``insert``:

      .. code:: python

          transaction.insert(
              'citizens',
              columns=['email', 'first_name', 'last_name', 'age'],
              values=[
                  ['phred@example.com', 'Phred', 'Phlyntstone', 32],
                  ['bharney@example.com', 'Bharney', 'Rhubble', 31],
              ],
          )


      Update records using Data Manipulation Language (DML) with a Transaction
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      .. code:: python

          spanner_client = spanner.Client()
          instance = spanner_client.instance(instance_id)
          database = instance.database(database_id)

          def update_albums(transaction):
              row_ct = transaction.execute_update(
                  "UPDATE Albums "
                  "SET MarketingBudget = MarketingBudget * 2 "
                  "WHERE SingerId = 1 and AlbumId = 1"
              )

              print("{} record(s) updated.".format(row_ct))

          database.run_in_transaction(update_albums)


      Update records using Mutations with a Transaction
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      ``Transaction.update`` updates one or more existing records in a table.  Fails
      if any of the records does not already exist.

      .. code:: python

          transaction.update(
              'citizens',
              columns=['email', 'age'],
              values=[
                  ['phred@example.com', 33],
                  ['bharney@example.com', 32],
              ],
          )


      Connection API
      --------------
      Connection API represents a wrap-around for Python Spanner API, written in accordance with PEP-249, and provides a simple way of communication with a Spanner database through connection objects:

      .. code:: python

         from google.cloud.spanner_dbapi.connection import connect

         connection = connect("instance-id", "database-id")
         connection.autocommit = True

         cursor = connection.cursor()   
         cursor.execute("SELECT * FROM table_name")

         result = cursor.fetchall()


      If using [fine-grained access controls](https://cloud.google.com/spanner/docs/access-with-fgac) you can pass a ``database_role`` argument to connect as that role:

      .. code:: python

         connection = connect("instance-id", "database-id", database_role='your-role')


      Aborted Transactions Retry Mechanism
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

      In ``!autocommit`` mode, transactions can be aborted due to transient errors. In most cases retry of an aborted transaction solves the problem. To simplify it, connection tracks SQL statements, executed in the current transaction. In case the transaction aborted, the connection initiates a new one and re-executes all the statements. In the process, the connection checks that retried statements are returning the same results that the original statements did. If results are different, the transaction is dropped, as the underlying data changed, and auto retry is impossible.

      Auto-retry of aborted transactions is enabled only for ``!autocommit`` mode, as in ``autocommit`` mode transactions are never aborted.


      Next Steps
    count: 1



    # Note: noxfile.py is heavily customized so we clobber the whole file. 
  - paths: [
      packages/google-cloud-spanner/noxfile.py
    ]
    before: |
      import os
      [\s\S]*?Run all tests with core dependencies installed from source
    after: |
      import os
      import pathlib
      import re
      import shutil
      import warnings
      from typing import Dict, List

      import nox

      RUFF_VERSION = "ruff==0.14.14"
      LINT_PATHS = ["google", "tests", "noxfile.py", "setup.py"]

      DEFAULT_PYTHON_VERSION = "3.14"

      DEFAULT_MOCK_SERVER_TESTS_PYTHON_VERSION = "3.12"
      SYSTEM_TEST_PYTHON_VERSIONS: List[str] = ["3.12"]

      ALL_PYTHON: List[str] = [
          "3.10",
          "3.11",
          "3.12",
          "3.13",
          "3.14",
          "3.15",
      ]
      UNIT_TEST_STANDARD_DEPENDENCIES = [
          "mock",
          "asyncmock",
          "pytest",
          "pytest-cov",
          "pytest-asyncio",
          "pytest-xdist",
      ]
      MOCK_SERVER_ADDITIONAL_DEPENDENCIES = [
          "google-cloud-testutils",
      ]
      UNIT_TEST_EXTERNAL_DEPENDENCIES: List[str] = []
      UNIT_TEST_LOCAL_DEPENDENCIES: List[str] = []
      UNIT_TEST_DEPENDENCIES: List[str] = []
      UNIT_TEST_EXTRAS: List[str] = []
      UNIT_TEST_EXTRAS_BY_PYTHON: Dict[str, List[str]] = {}

      SYSTEM_TEST_STANDARD_DEPENDENCIES: List[str] = [
          "mock",
          "pytest",
          "pytest-asyncio",
          "google-cloud-testutils",
      ]
      SYSTEM_TEST_EXTERNAL_DEPENDENCIES: List[str] = []
      SYSTEM_TEST_LOCAL_DEPENDENCIES: List[str] = []
      SYSTEM_TEST_DEPENDENCIES: List[str] = []
      SYSTEM_TEST_EXTRAS: List[str] = [
          "tracing",
      ]
      SYSTEM_TEST_EXTRAS_BY_PYTHON: Dict[str, List[str]] = {}

      CURRENT_DIRECTORY = pathlib.Path(__file__).parent.absolute()

      nox.options.sessions = [
          "unit-3.10",
          "unit-3.11",
          "unit-3.12",
          "unit-3.13",
          "unit-3.14",
          "system",
          "cover",
          "lint",
          "lint_setup_py",
          "blacken",
          "docs",
          "docfx",
          "format",
          "prerelease_deps",
          "core_deps_from_source",
          "mypy",
      ]
      
      # Error if a python version is missing
      nox.options.error_on_missing_interpreters = True


      @nox.session(python=DEFAULT_PYTHON_VERSION)
      def lint(session):
          """Run linters.

          Returns a failure if the linters find linting errors or sufficiently
          serious code quality issues.
          """
          session.install("flake8", RUFF_VERSION)

          # 2. Check formatting
          session.run(
              "ruff",
              "format",
              "--check",
              f"--target-version=py{ALL_PYTHON[0].replace('.', '')}",
              "--line-length=88",
              *LINT_PATHS,
          )

          session.run("flake8", "google", "tests")


      # Use a python runtime which is available in the owlbot post processor here
      # https://github.com/googleapis/synthtool/blob/master/docker/owlbot/python/Dockerfile
      @nox.session(python=DEFAULT_PYTHON_VERSION)
      def blacken(session):
          """(Deprecated) Legacy session. Please use 'nox -s format'."""
          session.log(
              "WARNING: The 'blacken' session is deprecated and will be removed in a future release. Please use 'nox -s format' in the future."
          )

          # Just run the ruff formatter (keeping legacy behavior of only formatting, not sorting imports)
          session.install(RUFF_VERSION)
          session.run(
              "ruff",
              "format",
              f"--target-version=py{ALL_PYTHON[0].replace('.', '')}",
              "--line-length=88",
              *LINT_PATHS,
          )


      @nox.session(python=DEFAULT_PYTHON_VERSION)
      def format(session):
          """
          Run ruff to sort imports and format code.
          """
          # 1. Install ruff (skipped automatically if you run with --no-venv)
          session.install(RUFF_VERSION)

          # 2. Run Ruff to fix imports
          # check --select I: Enables strict import sorting
          # --fix: Applies the changes automatically
          session.run(
              "ruff",
              "check",
              "--select",
              "I",
              "--fix",
              f"--target-version=py{ALL_PYTHON[0].replace('.', '')}",
              "--line-length=88",  # Standard Black line length
              *LINT_PATHS,
          )

          # 3. Run Ruff to format code
          session.run(
              "ruff",
              "format",
              f"--target-version=py{ALL_PYTHON[0].replace('.', '')}",
              "--line-length=88",  # Standard Black line length
              *LINT_PATHS,
          )


      @nox.session(python=DEFAULT_PYTHON_VERSION)
      def lint_setup_py(session):
          """Verify that setup.py is valid (including RST check)."""
          session.install("setuptools", "docutils", "pygments")
          session.run("python", "setup.py", "check", "--restructuredtext", "--strict")


      def install_unittest_dependencies(session, *constraints):
          standard_deps = UNIT_TEST_STANDARD_DEPENDENCIES + UNIT_TEST_DEPENDENCIES
          session.install(*standard_deps, *constraints)

          if UNIT_TEST_EXTERNAL_DEPENDENCIES:
              warnings.warn(
                  "'unit_test_external_dependencies' is deprecated. Instead, please "
                  "use 'unit_test_dependencies' or 'unit_test_local_dependencies'.",
                  DeprecationWarning,
              )
              session.install(*UNIT_TEST_EXTERNAL_DEPENDENCIES, *constraints)

          if UNIT_TEST_LOCAL_DEPENDENCIES:
              session.install(*UNIT_TEST_LOCAL_DEPENDENCIES, *constraints)

          if UNIT_TEST_EXTRAS_BY_PYTHON:
              extras = UNIT_TEST_EXTRAS_BY_PYTHON.get(session.python, [])
          elif UNIT_TEST_EXTRAS:
              extras = UNIT_TEST_EXTRAS
          else:
              extras = []

          if extras:
              session.install("-e", f".[{','.join(extras)}]", *constraints)
          else:
              session.install("-e", ".", *constraints)

          # XXX Work around Kokoro image's older pip, which borks the OT install.
          session.run("pip", "install", "--upgrade", "pip")
          constraints_path = str(
              CURRENT_DIRECTORY / "testing" / f"constraints-{session.python}.txt"
          )
          session.install("-e", ".[tracing]", "-c", constraints_path)
          # XXX: Dump installed versions to debug OT issue
          session.run("pip", "list")


      @nox.session(python=ALL_PYTHON)
      @nox.parametrize(
          "protobuf_implementation",
          ["python", "upb"],
      )
      def unit(session, protobuf_implementation):
          # Install all test dependencies, then install this package in-place.

          constraints_path = str(
              CURRENT_DIRECTORY / "testing" / f"constraints-{session.python}.txt"
          )
          install_unittest_dependencies(session, "-c", constraints_path)

          # Run py.test against the unit tests.
          args = [
              "py.test",
              "-n",
              "auto",
              "-s",
              f"--junitxml=unit_{session.python}_sponge_log.xml",
              "--cov=google",
              "--cov=tests/unit",
              "--cov-append",
              "--cov-config=.coveragerc",
              "--cov-report=",
              "--cov-fail-under=0",
          ]
          if not session.posargs:
              args.append(os.path.join("tests", "unit"))
          args.extend(session.posargs)

          session.run(
              *args,
              env={
                  "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
              },
          )


      @nox.session(python=DEFAULT_MOCK_SERVER_TESTS_PYTHON_VERSION)
      def mockserver(session):
          # Install all test dependencies, then install this package in-place.

          constraints_path = str(
              CURRENT_DIRECTORY / "testing" / f"constraints-{session.python}.txt"
          )
          standard_deps = (
              UNIT_TEST_STANDARD_DEPENDENCIES
              + UNIT_TEST_DEPENDENCIES
              + MOCK_SERVER_ADDITIONAL_DEPENDENCIES
          )
          session.install(*standard_deps, "-c", constraints_path)
          session.install("-e", ".", "-c", constraints_path)

          # Run py.test against the mockserver tests.
          session.run(
              "py.test",
              "--quiet",
              f"--junitxml=unit_{session.python}_sponge_log.xml",
              "--cov=google",
              "--cov=tests/unit",
              "--cov-append",
              "--cov-config=.coveragerc",
              "--cov-report=",
              "--cov-fail-under=0",
              os.path.join("tests", "mockserver_tests"),
              *session.posargs,
          )


      def install_systemtest_dependencies(session, *constraints):
          # Use pre-release gRPC for system tests.
          # Exclude version 1.52.0rc1 which has a known issue.
          # See https://github.com/grpc/grpc/issues/32163
          session.install("--pre", "grpcio!=1.52.0rc1")

          session.install(*SYSTEM_TEST_STANDARD_DEPENDENCIES, *constraints)

          if SYSTEM_TEST_EXTERNAL_DEPENDENCIES:
              session.install(*SYSTEM_TEST_EXTERNAL_DEPENDENCIES, *constraints)

          if SYSTEM_TEST_LOCAL_DEPENDENCIES:
              session.install("-e", *SYSTEM_TEST_LOCAL_DEPENDENCIES, *constraints)

          if SYSTEM_TEST_DEPENDENCIES:
              session.install("-e", *SYSTEM_TEST_DEPENDENCIES, *constraints)

          if SYSTEM_TEST_EXTRAS_BY_PYTHON:
              extras = SYSTEM_TEST_EXTRAS_BY_PYTHON.get(session.python, [])
          elif SYSTEM_TEST_EXTRAS:
              extras = SYSTEM_TEST_EXTRAS
          else:
              extras = []

          if extras:
              session.install("-e", f".[{','.join(extras)}]", *constraints)
          else:
              session.install("-e", ".", *constraints)


      @nox.session(python=SYSTEM_TEST_PYTHON_VERSIONS)
      @nox.parametrize(
          "protobuf_implementation,database_dialect",
          [
              ("python", "GOOGLE_STANDARD_SQL"),
              ("python", "POSTGRESQL"),
              ("upb", "GOOGLE_STANDARD_SQL"),
              ("upb", "POSTGRESQL"),
          ],
      )
      def system(session, protobuf_implementation, database_dialect):
          """Run the system test suite."""
          constraints_path = str(
              CURRENT_DIRECTORY / "testing" / f"constraints-{session.python}.txt"
          )
          system_test_path = os.path.join("tests", "system.py")
          system_test_folder_path = os.path.join("tests", "system")

          # Check the value of `RUN_SYSTEM_TESTS` env var. It defaults to true.
          if os.environ.get("RUN_SYSTEM_TESTS", "true") == "false":
              session.skip("RUN_SYSTEM_TESTS is set to false, skipping")
          # Sanity check: Only run tests if the environment variable is set.
          if not os.environ.get("GOOGLE_APPLICATION_CREDENTIALS", "") and not os.environ.get(
              "SPANNER_EMULATOR_HOST", ""
          ):
              session.skip(
                  "Credentials or emulator host must be set via environment variable"
              )
          if not (
              os.environ.get("SPANNER_EMULATOR_HOST") or protobuf_implementation == "python"
          ):
              session.skip(
                  "Only run system tests on real Spanner with one protobuf implementation to speed up the build"
              )

          # Install pyopenssl for mTLS testing.
          if os.environ.get("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false") == "true":
              session.install("pyopenssl")

          system_test_exists = os.path.exists(system_test_path)
          system_test_folder_exists = os.path.exists(system_test_folder_path)
          # Sanity check: only run tests if found.
          if not system_test_exists and not system_test_folder_exists:
              session.skip("System tests were not found")

          install_systemtest_dependencies(session, "-c", constraints_path)

          # Run py.test against the system tests.
          if system_test_exists:
              args = [
                  "py.test",
                  "--quiet",
                  "-o",
                  "asyncio_mode=auto",
                  f"--junitxml=system_{session.python}_sponge_log.xml",
              ]
              if not session.posargs:
                  args.append(system_test_path)
              args.extend(session.posargs)

              session.run(
                  *args,
                  env={
                      "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
                      "SPANNER_DATABASE_DIALECT": database_dialect,
                      "SKIP_BACKUP_TESTS": "true",
                  },
              )
          elif system_test_folder_exists:
              # Run sync tests
              sync_args = [
                  "py.test",
                  "--quiet",
                  "-o",
                  "asyncio_mode=auto",
                  f"--junitxml=system_{session.python}_sync_sponge_log.xml",
              ]
              if not session.posargs:
                  sync_args.append(os.path.join("tests", "system"))
                  sync_args.append("--ignore=tests/system/_async")
              else:
                  sync_args.extend(session.posargs)

              session.run(
                  *sync_args,
                  env={
                      "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
                      "SPANNER_DATABASE_DIALECT": database_dialect,
                      "SKIP_BACKUP_TESTS": "true",
                  },
              )

              # Run async tests
              async_args = [
                  "py.test",
                  "--quiet",
                  "-o",
                  "asyncio_mode=auto",
                  f"--junitxml=system_{session.python}_async_sponge_log.xml",
              ]
              if not session.posargs:
                  async_args.append(os.path.join("tests", "system", "_async"))
              else:
                  # If posargs are provided, only run if they match async tests
                  # or just skip if they were already run in sync.
                  # For simplicity, we only run async folder if no posargs.
                  return

              session.run(
                  *async_args,
                  env={
                      "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
                      "SPANNER_DATABASE_DIALECT": database_dialect,
                      "SKIP_BACKUP_TESTS": "true",
                  },
              )


      @nox.session(python=DEFAULT_PYTHON_VERSION)
      def cover(session):
          """Run the final coverage report.

          This outputs the coverage report aggregating coverage from the unit
          test runs (not system test runs), and then erases coverage data.
          """
          session.install("coverage", "pytest-cov")
          session.run("coverage", "report", "--show-missing", "--fail-under=98")

          session.run("coverage", "erase")


      @nox.session(python="3.10")
      def docs(session):
          """Build the docs for this library."""

          session.install("-e", ".[tracing]")
          session.install(
              # We need to pin to specific versions of the `sphinxcontrib-*` packages
              # which still support sphinx 4.x.
              # See https://github.com/googleapis/sphinx-docfx-yaml/issues/344
              # and https://github.com/googleapis/sphinx-docfx-yaml/issues/345.
              "sphinxcontrib-applehelp==1.0.4",
              "sphinxcontrib-devhelp==1.0.2",
              "sphinxcontrib-htmlhelp==2.0.1",
              "sphinxcontrib-qthelp==1.0.3",
              "sphinxcontrib-serializinghtml==1.1.5",
              "sphinx==4.5.0",
              "alabaster",
              "recommonmark",
          )

          shutil.rmtree(os.path.join("docs", "_build"), ignore_errors=True)
          session.run(
              "sphinx-build",
              "-W",  # warnings as errors
              "-T",  # show full traceback on exception
              "-N",  # no colors
              "-b",
              "html",
              "-d",
              os.path.join("docs", "_build", "doctrees", ""),
              os.path.join("docs", ""),
              os.path.join("docs", "_build", "html", ""),
          )


      @nox.session(python="3.10")
      def docfx(session):
          """Build the docfx yaml files for this library."""

          session.install("-e", ".[tracing]")
          session.install(
              # We need to pin to specific versions of the `sphinxcontrib-*` packages
              # which still support sphinx 4.x.
              # See https://github.com/googleapis/sphinx-docfx-yaml/issues/344
              # and https://github.com/googleapis/sphinx-docfx-yaml/issues/345.
              "sphinxcontrib-applehelp==1.0.4",
              "sphinxcontrib-devhelp==1.0.2",
              "sphinxcontrib-htmlhelp==2.0.1",
              "sphinxcontrib-qthelp==1.0.3",
              "sphinxcontrib-serializinghtml==1.1.5",
              "gcp-sphinx-docfx-yaml",
              "alabaster",
              "recommonmark",
          )

          shutil.rmtree(os.path.join("docs", "_build"), ignore_errors=True)
          session.run(
              "sphinx-build",
              "-T",  # show full traceback on exception
              "-N",  # no colors
              "-D",
              (
                  "extensions=sphinx.ext.autodoc,"
                  "sphinx.ext.autosummary,"
                  "docfx_yaml.extension,"
                  "sphinx.ext.intersphinx,"
                  "sphinx.ext.coverage,"
                  "sphinx.ext.napoleon,"
                  "sphinx.ext.todo,"
                  "sphinx.ext.viewcode,"
                  "recommonmark"
              ),
              "-b",
              "html",
              "-d",
              os.path.join("docs", "_build", "doctrees", ""),
              os.path.join("docs", ""),
              os.path.join("docs", "_build", "html", ""),
          )


      @nox.session(python="3.14")
      @nox.parametrize(
          "protobuf_implementation,database_dialect",
          [
              ("python", "GOOGLE_STANDARD_SQL"),
              ("python", "POSTGRESQL"),
              ("upb", "GOOGLE_STANDARD_SQL"),
              ("upb", "POSTGRESQL"),
          ],
      )
      def prerelease_deps(session, protobuf_implementation, database_dialect):
          """Run all tests with prerelease versions of dependencies installed."""

          # Install all dependencies
          session.install("-e", ".[all, tests, tracing]")
          unit_deps_all = UNIT_TEST_STANDARD_DEPENDENCIES + UNIT_TEST_EXTERNAL_DEPENDENCIES
          session.install(*unit_deps_all)
          system_deps_all = (
              SYSTEM_TEST_STANDARD_DEPENDENCIES + SYSTEM_TEST_EXTERNAL_DEPENDENCIES
          )
          session.install(*system_deps_all)

          # Because we test minimum dependency versions on the minimum Python
          # version, the first version we test with in the unit tests sessions has a
          # constraints file containing all dependencies and extras.
          with open(
              CURRENT_DIRECTORY / "testing" / f"constraints-{ALL_PYTHON[0]}.txt",
              encoding="utf-8",
          ) as constraints_file:
              constraints_text = constraints_file.read()

          # Ignore leading whitespace and comment lines.
          constraints_deps = [
              match.group(1)
              for match in re.finditer(
                  r"^\\s*([a-zA-Z0-9._-]+)", constraints_text, flags=re.MULTILINE
              )
          ]

          if constraints_deps:
              session.install(*constraints_deps)

          prerel_deps = [
              "protobuf",
              # dependency of grpc
              "six",
              "grpc-google-iam-v1",
              "googleapis-common-protos",
              "grpcio",
              "grpcio-status",
              "google-api-core",
              "google-auth",
              "proto-plus",
              "google-cloud-testutils",
              # dependencies of google-cloud-testutils"
              "click",
              # dependency of google-auth
              "cffi",
              "cryptography",
              "cachetools",
          ]

          for dep in prerel_deps:
              session.install("--pre", "--no-deps", "--upgrade", dep)

          # Remaining dependencies
          other_deps = [
              "requests",
          ]
          session.install(*other_deps)

          # Print out prerelease package versions
          session.run(
              "python", "-c", "import google.protobuf; print(google.protobuf.__version__)"
          )
          session.run("python", "-c", "import grpc; print(grpc.__version__)")
          session.run("python", "-c", "import google.auth; print(google.auth.__version__)")

          session.run(
              "py.test",
              "tests/unit",
              env={
                  "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
                  "SPANNER_DATABASE_DIALECT": database_dialect,
                  "SKIP_BACKUP_TESTS": "true",
              },
          )

          system_test_path = os.path.join("tests", "system.py")
          system_test_folder_path = os.path.join("tests", "system")

          system_test_exists = os.path.exists(system_test_path)
          system_test_folder_exists = os.path.exists(system_test_folder_path)
          # Sanity check: only run tests if found.
          if not system_test_exists and not system_test_folder_exists:
              session.skip("System tests were not found")

          if os.environ.get("SPANNER_EMULATOR_HOST"):
              # Run tests against the emulator
              run_system = True
          elif protobuf_implementation == "python":
              # Run tests against real Spanner, but check creds first
              if os.environ.get("GOOGLE_APPLICATION_CREDENTIALS"):
                  run_system = True
              else:
                  session.log(
                      "Skipping system tests because GOOGLE_APPLICATION_CREDENTIALS is not set"
                  )
                  run_system = False
          else:
              # Skip to speed up build (only run python implementation on real Spanner)
              session.log(
                  f"Skipping system tests for protobuf={protobuf_implementation} on real Spanner to speed up build"
              )
              run_system = False

          if run_system:
              # Run py.test against the system tests.
              if system_test_exists:
                  args = [
                      "py.test",
                      "--quiet",
                      "-o",
                      "asyncio_mode=auto",
                      f"--junitxml=system_{session.python}_sponge_log.xml",
                  ]
                  if not session.posargs:
                      args.append(system_test_path)
                  args.extend(session.posargs)
  
                  session.run(
                      *args,
                      env={
                          "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
                          "SPANNER_DATABASE_DIALECT": database_dialect,
                          "SKIP_BACKUP_TESTS": "true",
                      },
                  )
              elif system_test_folder_exists:
                  # Run sync tests
                  sync_args = [
                      "py.test",
                      "--quiet",
                      "-o",
                      "asyncio_mode=auto",
                      f"--junitxml=system_{session.python}_sync_sponge_log.xml",
                  ]
                  if not session.posargs:
                      sync_args.append(system_test_folder_path)
                      sync_args.append(
                          f"--ignore={os.path.join(system_test_folder_path, '_async')}"
                      )
                  else:
                      sync_args.extend(session.posargs)

                  session.run(
                      *sync_args,
                      env={
                          "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
                          "SPANNER_DATABASE_DIALECT": database_dialect,
                          "SKIP_BACKUP_TESTS": "true",
                      },
                  )

                  # Run async tests
                  async_args = [
                      "py.test",
                      "--quiet",
                      "-o",
                      "asyncio_mode=auto",
                      f"--junitxml=system_{session.python}_async_sponge_log.xml",
                  ]
                  if not session.posargs:
                      async_args.append(os.path.join(system_test_folder_path, "_async"))
                  else:
                      # If posargs are provided, only run if they match async tests
                      # or just skip if they were already run in sync.
                      # For simplicity, we only run async folder if no posargs.
                      return

                  session.run(
                      *async_args,
                      env={
                          "PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION": protobuf_implementation,
                          "SPANNER_DATABASE_DIALECT": database_dialect,
                          "SKIP_BACKUP_TESTS": "true",
                      },
                  )


      @nox.session(python=ALL_PYTHON)
      def mypy(session):
          """Run the type checker."""
          session.skip("Mypy is not yet supported")
          # TODO(https://github.com/googleapis/gapic-generator-python/issues/2579):
          # use the latest version of mypy
          session.install(
              "mypy<1.16.0",
              "types-requests",
              "types-protobuf",
          )
          session.install(".")
          session.run(
              "mypy",
              "-p",
              "google",
              # "--check-untyped-defs",
              *session.posargs,
          )


      @nox.session(python=DEFAULT_PYTHON_VERSION)
      @nox.parametrize(
          "protobuf_implementation",
          ["python", "upb"],
      )
      def core_deps_from_source(session, protobuf_implementation):
          """Run all tests with core dependencies installed from source,
    count: 1
  - paths: [packages/google-cloud-spanner/testing/constraints-3.10.txt]
    before: '(?s)protobuf==6.33.5\n(?!google-cloud-core)'
    after: |
      protobuf==6.33.5
      google-cloud-core==2.0.0
      grpc-google-iam-v1==0.14.2
      grpcio-status==1.59.0
      sqlparse==0.4.4
      grpc-interceptor==0.15.4
      opentelemetry-api==1.22.0
      opentelemetry-sdk==1.22.0
      opentelemetry-semantic-conventions==0.43b0
      opentelemetry-resourcedetector-gcp==1.8.0a0
      google-cloud-monitoring==2.28.0
      mmh3==4.1.0
      libcst==0.2.5
      googleapis-common-protos==1.69.2
    count: 1
  - paths: [
      packages/google-cloud-spanner/noxfile.py
    ]
    before: |
        session.install\(\*dep_paths, "--no-deps", "--ignore-installed"\)
        [\s\S]*?session.run\(\s+"py.test",\s+"tests/unit",
    after: |
        session.install(*dep_paths, "--no-deps", "--ignore-installed")
            session.install("pytest-xdist")
            print(
                f"Installed {', '.join(core_dependencies_from_source)} locally from {deps_dir}"
            )

            session.run(
                "py.test",
                "-n",
                "auto",
                "tests/unit",
    count: 1
  - paths: [packages/google-cloud-spanner/.coveragerc]
    before: |
      \[report\]
      show_missing = True
    after: |
      [report]
      fail_under = 98
      show_missing = True
    count: 1