datastore-integration.yaml

# Copyright 2023 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 Datastore Handwritten code
# TODO(Fill in issue number below to add more context)
url: https://github.com/googleapis/gapic-generator-python/issues/123
replacements:
  - paths: [
      "packages/google-cloud-datastore/docs/conf.py",
    ]
    before: |
      exclude_patterns = \[
      \    "_build",
    after: |
      exclude_patterns = [
          "datastore_admin_v1/**",
          "datastore_v1/**",
          "multiprocessing.rst",
          "_build",
    count: 1
  - paths: [
      "packages/google-cloud-datastore/setup.py"
    ]
    before: |
      "google-auth >= 2.14.1, <3.0.0,!=2.24.0,!=2.25.0",
      \    "grpcio >= 1.59.0, < 2.0.0",
    after: |
      "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",
    count: 1
  - paths: [
      "packages/google-cloud-datastore/docs/index.rst",
    ]
    before: |
      \.\. include:: multiprocessing\.rst[\s\S]*?CHANGELOG
    after: |
      .. note::

         Because the Datastore client uses the :mod:`grpcio` library by default
         and uses third-party :mod:`requests` library if the GRPC is disabled,
         clients are safe to share instances across threads.  In multiprocessing
         scenarios, the best practice is to create client instances *after*
         :class:`multiprocessing.Pool` or :class:`multiprocessing.Process` invokes
         :func:`os.fork`.

      API Reference
      -------------
      .. toctree::
          :maxdepth: 2

          client
          entities
          keys
          queries
          aggregations
          transactions
          batches
          helpers
          admin_client

      Changelog
      ---------

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

      .. toctree::
          :maxdepth: 2

          CHANGELOG
    count: 1
  - paths: [
      "packages/google-cloud-datastore/google/cloud/datastore/__init__.py",
    ]
    before: |
      from google.cloud.datastore import gapic_version as package_version
      [\s\S]*?"PlanSummary",\n\)
    after: |
      """Shortcut methods for getting set up with Google Cloud Datastore.

      You'll typically use these to get started with the API:

      .. doctest:: constructors

         >>> from google.cloud import datastore
         >>>
         >>> client = datastore.Client()
         >>> key = client.key('EntityKind', 1234)
         >>> key
         <Key('EntityKind', 1234), project=...>
         >>> entity = datastore.Entity(key)
         >>> entity['question'] = u'Life, universe?'  # Explicit unicode for text
         >>> entity['answer'] = 42
         >>> entity
         <Entity('EntityKind', 1234) {'question': 'Life, universe?', 'answer': 42}>
         >>> query = client.query(kind='EntityKind')

      The main concepts with this API are:

      - :class:`~google.cloud.datastore.client.Client`
        which represents a project (string), database (string), and namespace
        (string) bundled with a connection and has convenience methods for
        constructing objects with that project/database/namespace.

      - :class:`~google.cloud.datastore.entity.Entity`
        which represents a single entity in the datastore
        (akin to a row in relational database world).

      - :class:`~google.cloud.datastore.key.Key`
        which represents a pointer to a particular entity in the datastore
        (akin to a unique identifier in relational database world).

      - :class:`~google.cloud.datastore.query.Query`
        which represents a lookup or search over the rows in the datastore.

      - :class:`~google.cloud.datastore.transaction.Transaction`
        which represents an all-or-none transaction and enables consistency
        when race conditions may occur.
      """

      from google.cloud.datastore.batch import Batch
      from google.cloud.datastore.client import Client
      from google.cloud.datastore.entity import Entity
      from google.cloud.datastore.key import Key
      from google.cloud.datastore.query import Query
      from google.cloud.datastore.query_profile import ExplainOptions
      from google.cloud.datastore.transaction import Transaction
      from google.cloud.datastore.version import __version__

      __all__ = [
          "__version__",
          "Batch",
          "Client",
          "Entity",
          "Key",
          "Query",
          "ExplainOptions",
          "Transaction",
      ]
    count: 1
  - paths: [
      "packages/google-cloud-datastore/noxfile.py",
    ]
    before: |
      @nox\.session\(python=SYSTEM_TEST_PYTHON_VERSIONS\)
      def system\(session\):\s+"""Run the system test suite\."""[\s\S]*?system_test_folder_path,\s*\*session\.posargs,\s*\)
    after: |
      @nox.session(python=SYSTEM_TEST_PYTHON_VERSIONS)
      @nox.parametrize("disable_grpc", [False, True])
      def system(session, disable_grpc):
          """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")
          # 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)

          env = {}
          if disable_grpc:
              env["GOOGLE_CLOUD_DISABLE_GRPC"] = "True"

          # Run py.test against the system tests.
          if system_test_exists:
              session.run(
                  "py.test",
                  "--quiet",
                  f"--junitxml=system_{session.python}_sponge_log.xml",
                  system_test_path,
                  env=env,
                  *session.posargs,
              )
          if system_test_folder_exists:
              session.run(
                  "py.test",
                  "--quiet",
                  f"--junitxml=system_{session.python}_sponge_log.xml",
                  system_test_folder_path,
                  env=env,
                  *session.posargs,
              )
    count: 1