diff --git a/packages/google-cloud-bigtable/samples/AUTHORING_GUIDE.md b/packages/google-cloud-bigtable/samples/AUTHORING_GUIDE.md
new file mode 100644
index 000000000000..8249522ffc2d
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/AUTHORING_GUIDE.md
@@ -0,0 +1 @@
+See https://github.com/GoogleCloudPlatform/python-docs-samples/blob/main/AUTHORING_GUIDE.md
\ No newline at end of file
diff --git a/packages/google-cloud-bigtable/samples/CONTRIBUTING.md b/packages/google-cloud-bigtable/samples/CONTRIBUTING.md
new file mode 100644
index 000000000000..f5fe2e6baf13
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/CONTRIBUTING.md
@@ -0,0 +1 @@
+See https://github.com/GoogleCloudPlatform/python-docs-samples/blob/main/CONTRIBUTING.md
\ No newline at end of file
diff --git a/packages/google-cloud-bigtable/samples/README.md b/packages/google-cloud-bigtable/samples/README.md
new file mode 100644
index 000000000000..1301c6fb1f60
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/README.md
@@ -0,0 +1,24 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a refererence for how to use this product.
+
+## Additional Information
+
+You can read the documentation for more details on API usage and use GitHub
+to browse the source and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/__init__.py b/packages/google-cloud-bigtable/samples/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/beam/__init__.py b/packages/google-cloud-bigtable/samples/beam/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/beam/hello_world_write.py b/packages/google-cloud-bigtable/samples/beam/hello_world_write.py
new file mode 100644
index 000000000000..06c9505f2f29
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/beam/hello_world_write.py
@@ -0,0 +1,70 @@
+# Copyright 2020 Google Inc.
+#
+# 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.
+import datetime
+
+import apache_beam as beam
+from apache_beam.io.gcp.bigtableio import WriteToBigTable
+from apache_beam.options.pipeline_options import PipelineOptions
+
+from google.cloud.bigtable import row
+
+
+class BigtableOptions(PipelineOptions):
+ @classmethod
+ def _add_argparse_args(cls, parser):
+ parser.add_argument(
+ "--bigtable-project",
+ help="The Bigtable project ID, this can be different than your "
+ "Dataflow project",
+ default="bigtable-project",
+ )
+ parser.add_argument(
+ "--bigtable-instance",
+ help="The Bigtable instance ID",
+ default="bigtable-instance",
+ )
+ parser.add_argument(
+ "--bigtable-table",
+ help="The Bigtable table ID in the instance.",
+ default="bigtable-table",
+ )
+
+
+class CreateRowFn(beam.DoFn):
+ def process(self, key):
+ direct_row = row.DirectRow(row_key=key)
+ direct_row.set_cell(
+ "stats_summary", b"os_build", b"android", datetime.datetime.now()
+ )
+ return [direct_row]
+
+
+def run(argv=None):
+ """Build and run the pipeline."""
+ options = BigtableOptions(argv)
+ with beam.Pipeline(options=options) as p:
+ (
+ p
+ | beam.Create(["phone#4c410523#20190501", "phone#4c410523#20190502"])
+ | beam.ParDo(CreateRowFn())
+ | WriteToBigTable(
+ project_id=options.bigtable_project,
+ instance_id=options.bigtable_instance,
+ table_id=options.bigtable_table,
+ )
+ )
+
+
+if __name__ == "__main__":
+ run()
diff --git a/packages/google-cloud-bigtable/samples/beam/hello_world_write_test.py b/packages/google-cloud-bigtable/samples/beam/hello_world_write_test.py
new file mode 100644
index 000000000000..82490ec7855e
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/beam/hello_world_write_test.py
@@ -0,0 +1,48 @@
+# Copyright 2020 Google Inc.
+#
+# 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.
+import os
+import uuid
+
+import pytest
+
+from ..utils import create_table_cm
+from . import hello_world_write
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"mobile-time-series-beam-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture(scope="module", autouse=True)
+def table():
+ with create_table_cm(
+ PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None}
+ ) as table:
+ yield table
+
+
+def test_hello_world_write(table):
+ hello_world_write.run(
+ [
+ "--bigtable-project=%s" % PROJECT,
+ "--bigtable-instance=%s" % BIGTABLE_INSTANCE,
+ "--bigtable-table=%s" % TABLE_ID,
+ ]
+ )
+
+ rows = table.read_rows()
+ count = 0
+ for _ in rows:
+ count += 1
+ assert count == 2
diff --git a/packages/google-cloud-bigtable/samples/beam/noxfile.py b/packages/google-cloud-bigtable/samples/beam/noxfile.py
new file mode 100644
index 000000000000..1b8f66b398c9
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/beam/noxfile.py
@@ -0,0 +1,290 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+# todo(kolea2): temporary workaround to install pinned dep version
+INSTALL_LIBRARY_FROM_SOURCE = False
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/beam/noxfile_config.py b/packages/google-cloud-bigtable/samples/beam/noxfile_config.py
new file mode 100644
index 000000000000..66d7bc5aca17
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/beam/noxfile_config.py
@@ -0,0 +1,45 @@
+# Copyright 2021 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.
+
+# Default TEST_CONFIG_OVERRIDE for python repos.
+
+# You can copy this file into your directory, then it will be imported from
+# the noxfile.py.
+
+# The source of truth:
+# https://github.com/GoogleCloudPlatform/python-docs-samples/blob/main/noxfile_config.py
+
+TEST_CONFIG_OVERRIDE = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [
+ "3.7", # Beam no longer supports Python 3.7 for new releases
+ "3.12", # Beam not yet supported for Python 3.12
+ ],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
diff --git a/packages/google-cloud-bigtable/samples/beam/requirements-test.txt b/packages/google-cloud-bigtable/samples/beam/requirements-test.txt
new file mode 100644
index 000000000000..e079f8a6038d
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/beam/requirements-test.txt
@@ -0,0 +1 @@
+pytest
diff --git a/packages/google-cloud-bigtable/samples/beam/requirements.txt b/packages/google-cloud-bigtable/samples/beam/requirements.txt
new file mode 100644
index 000000000000..e709a03cb849
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/beam/requirements.txt
@@ -0,0 +1,5 @@
+apache-beam===2.60.0; python_version == '3.8'
+apache-beam===2.69.0; python_version == '3.9'
+apache-beam==2.71.0; python_version >= '3.10'
+google-cloud-bigtable==2.35.0
+google-cloud-core==2.5.0
diff --git a/packages/google-cloud-bigtable/samples/hello/README.md b/packages/google-cloud-bigtable/samples/hello/README.md
new file mode 100644
index 000000000000..b3779fb43b27
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello/README.md
@@ -0,0 +1,52 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a refererence for how to use this product.
+Samples, quickstarts, and other documentation are available at cloud.google.com.
+
+
+### Hello World in Cloud Bigtable
+
+Demonstrates how to connect to Cloud Bigtable and run some basic operations. More information available at: https://cloud.google.com/bigtable/docs/samples-python-hello
+
+
+
+
+
+To run this sample:
+
+1. If this is your first time working with GCP products, you will need to set up [the Cloud SDK][cloud_sdk] or utilize [Google Cloud Shell][gcloud_shell]. This sample may [require authentication][authentication] and you will need to [enable billing][enable_billing].
+
+1. Make a fork of this repo and clone the branch locally, then navigate to the sample directory you want to use.
+
+1. Install the dependencies needed to run the samples.
+
+ pip install -r requirements.txt
+
+1. Run the sample using
+
+ python main.py
+
+
+
+usage: main.py [-h] [--table TABLE] project_id instance_id
Demonstrates how to connect to Cloud Bigtable and run some basic operations.
Prerequisites: - Create a Cloud Bigtable cluster.
https://cloud.google.com/bigtable/docs/creating-cluster - Set your Google
Application Default Credentials.
https://developers.google.com/identity/protocols/application-default-
credentials
positional arguments:
project_id Your Cloud Platform project ID.
instance_id ID of the Cloud Bigtable instance to connect to.
optional arguments:
-h, --help show this help message and exit
--table TABLE Table to create and destroy. (default: Hello-Bigtable)
+
+## Additional Information
+
+You can read the documentation for more details on API usage and use GitHub
+to browse the source and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/hello/__init__.py b/packages/google-cloud-bigtable/samples/hello/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/hello/async_main.py b/packages/google-cloud-bigtable/samples/hello/async_main.py
new file mode 100644
index 000000000000..c26a74faeead
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello/async_main.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+
+# Copyright 2024 Google Inc.
+#
+# 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.
+
+"""Demonstrates how to connect to Cloud Bigtable and run some basic operations with the async APIs
+
+Prerequisites:
+
+- Create a Cloud Bigtable instance.
+ https://cloud.google.com/bigtable/docs/creating-instance
+- Set your Google Application Default Credentials.
+ https://developers.google.com/identity/protocols/application-default-credentials
+"""
+
+import argparse
+import asyncio
+
+# [START bigtable_async_hw_imports]
+from google.cloud import bigtable
+from google.cloud.bigtable.data import row_filters
+
+from ..utils import wait_for_table
+
+# [END bigtable_async_hw_imports]
+
+# use to ignore warnings
+row_filters
+
+
+async def main(project_id, instance_id, table_id):
+ # [START bigtable_async_hw_connect]
+ client = bigtable.data.BigtableDataClientAsync(project=project_id)
+ table = client.get_table(instance_id, table_id)
+ # [END bigtable_async_hw_connect]
+
+ # [START bigtable_async_hw_create_table]
+ from google.cloud.bigtable import column_family
+
+ # the async client only supports the data API. Table creation as an admin operation
+ # use admin client to create the table
+ print("Creating the {} table.".format(table_id))
+ admin_client = bigtable.Client(project=project_id, admin=True)
+ admin_instance = admin_client.instance(instance_id)
+ admin_table = admin_instance.table(table_id)
+
+ print("Creating column family cf1 with Max Version GC rule...")
+ # Create a column family with GC policy : most recent N versions
+ # Define the GC policy to retain only the most recent 2 versions
+ max_versions_rule = column_family.MaxVersionsGCRule(2)
+ column_family_id = b"cf1"
+ column_families = {column_family_id: max_versions_rule}
+ if not admin_table.exists():
+ admin_table.create(column_families=column_families)
+ else:
+ print("Table {} already exists.".format(table_id))
+ # [END bigtable_async_hw_create_table]
+
+ try:
+ # let table creation complete
+ wait_for_table(admin_table)
+ # [START bigtable_async_hw_write_rows]
+ print("Writing some greetings to the table.")
+ greetings = [b"Hello World!", b"Hello Cloud Bigtable!", b"Hello Python!"]
+ mutations = []
+ column = b"greeting"
+ for i, value in enumerate(greetings):
+ # Note: This example uses sequential numeric IDs for simplicity,
+ # but this can result in poor performance in a production
+ # application. Since rows are stored in sorted order by key,
+ # sequential keys can result in poor distribution of operations
+ # across nodes.
+ #
+ # We recommend that you use bytestrings directly for row keys
+ # where possible, rather than encoding strings.
+ #
+ # For more information about how to design a Bigtable schema for
+ # the best performance, see the documentation:
+ #
+ # https://cloud.google.com/bigtable/docs/schema-design
+ row_key = f"greeting{i}".encode()
+ row_mutation = bigtable.data.RowMutationEntry(
+ row_key, bigtable.data.SetCell(column_family_id, column, value)
+ )
+ mutations.append(row_mutation)
+ await table.bulk_mutate_rows(mutations)
+ # [END bigtable_async_hw_write_rows]
+
+ # [START bigtable_async_hw_create_filter]
+ # Create a filter to only retrieve the most recent version of the cell
+ # for each column across entire row.
+ row_filter = bigtable.data.row_filters.CellsColumnLimitFilter(1)
+ # [END bigtable_async_hw_create_filter]
+
+ # [START bigtable_async_hw_get_with_filter]
+ # [START bigtable_async_hw_get_by_key]
+ print("Getting a single greeting by row key.")
+ key = "greeting0".encode()
+
+ row = await table.read_row(key, row_filter=row_filter)
+ cell = row.cells[0]
+ print(cell.value.decode("utf-8"))
+ # [END bigtable_async_hw_get_by_key]
+ # [END bigtable_async_hw_get_with_filter]
+
+ # [START bigtable_async_hw_scan_with_filter]
+ # [START bigtable_async_hw_scan_all]
+ print("Scanning for all greetings:")
+ query = bigtable.data.ReadRowsQuery(row_filter=row_filter)
+ async for row in await table.read_rows_stream(query):
+ cell = row.cells[0]
+ print(cell.value.decode("utf-8"))
+ # [END bigtable_async_hw_scan_all]
+ # [END bigtable_async_hw_scan_with_filter]
+ finally:
+ # [START bigtable_async_hw_delete_table]
+ # the async client only supports the data API. Table deletion as an admin operation
+ # use admin client to create the table
+ print("Deleting the {} table.".format(table_id))
+ admin_table.delete()
+ # [END bigtable_async_hw_delete_table]
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
+ )
+ parser.add_argument("project_id", help="Your Cloud Platform project ID.")
+ parser.add_argument(
+ "instance_id", help="ID of the Cloud Bigtable instance to connect to."
+ )
+ parser.add_argument(
+ "--table", help="Table to create and destroy.", default="Hello-Bigtable"
+ )
+
+ args = parser.parse_args()
+ asyncio.run(main(args.project_id, args.instance_id, args.table))
diff --git a/packages/google-cloud-bigtable/samples/hello/async_main_test.py b/packages/google-cloud-bigtable/samples/hello/async_main_test.py
new file mode 100644
index 000000000000..4f09d01e5630
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello/async_main_test.py
@@ -0,0 +1,36 @@
+# Copyright 2024 Google Inc.
+#
+# 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.
+
+import asyncio
+import os
+import uuid
+
+from .async_main import main
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"hello-world-test-async-{str(uuid.uuid4())[:16]}"
+
+
+def test_async_main(capsys):
+ asyncio.run(main(PROJECT, BIGTABLE_INSTANCE, TABLE_ID))
+
+ out, _ = capsys.readouterr()
+ assert "Creating the {} table.".format(TABLE_ID) in out
+ assert "Writing some greetings to the table." in out
+ assert "Getting a single greeting by row key." in out
+ assert "Hello World!" in out
+ assert "Scanning for all greetings" in out
+ assert "Hello Cloud Bigtable!" in out
+ assert "Deleting the {} table.".format(TABLE_ID) in out
diff --git a/packages/google-cloud-bigtable/samples/hello/main.py b/packages/google-cloud-bigtable/samples/hello/main.py
new file mode 100644
index 000000000000..13899a87425b
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello/main.py
@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+
+# Copyright 2016 Google Inc.
+#
+# 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.
+
+"""Demonstrates how to connect to Cloud Bigtable and run some basic operations.
+
+Prerequisites:
+
+- Create a Cloud Bigtable instance.
+ https://cloud.google.com/bigtable/docs/creating-instance
+- Set your Google Application Default Credentials.
+ https://developers.google.com/identity/protocols/application-default-credentials
+"""
+
+import argparse
+
+# [START bigtable_hw_imports]
+from datetime import datetime, timezone
+
+from google.cloud import bigtable
+from google.cloud.bigtable import column_family, row_filters
+
+from ..utils import wait_for_table
+
+# [END bigtable_hw_imports]
+
+# use to avoid warnings
+row_filters
+column_family
+
+
+def main(project_id, instance_id, table_id):
+ # [START bigtable_hw_connect]
+ # The client must be created with admin=True because it will create a
+ # table.
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ # [END bigtable_hw_connect]
+
+ # [START bigtable_hw_create_table]
+ print("Creating the {} table.".format(table_id))
+ table = instance.table(table_id)
+
+ print("Creating column family cf1 with Max Version GC rule...")
+ # Create a column family with GC policy : most recent N versions
+ # Define the GC policy to retain only the most recent 2 versions
+ max_versions_rule = bigtable.column_family.MaxVersionsGCRule(2)
+ column_family_id = b"cf1"
+ column_families = {column_family_id: max_versions_rule}
+ if not table.exists():
+ table.create(column_families=column_families)
+ else:
+ print("Table {} already exists.".format(table_id))
+ # [END bigtable_hw_create_table]
+
+ try:
+ # let table creation complete
+ wait_for_table(table)
+
+ # [START bigtable_hw_write_rows]
+ print("Writing some greetings to the table.")
+ greetings = [b"Hello World!", b"Hello Cloud Bigtable!", b"Hello Python!"]
+ rows = []
+ column = b"greeting"
+ for i, value in enumerate(greetings):
+ # Note: This example uses sequential numeric IDs for simplicity,
+ # but this can result in poor performance in a production
+ # application. Since rows are stored in sorted order by key,
+ # sequential keys can result in poor distribution of operations
+ # across nodes.
+ #
+ # We recommend that you use bytestrings directly for row keys
+ # where possible, rather than encoding strings.
+ #
+ # For more information about how to design a Bigtable schema for
+ # the best performance, see the documentation:
+ #
+ # https://cloud.google.com/bigtable/docs/schema-design
+ row_key = f"greeting{i}".encode()
+ row = table.direct_row(row_key)
+ row.set_cell(
+ column_family_id,
+ column,
+ value,
+ timestamp=datetime.now(timezone.utc),
+ )
+ rows.append(row)
+ table.mutate_rows(rows)
+ # [END bigtable_hw_write_rows]
+
+ # [START bigtable_hw_create_filter]
+ # Create a filter to only retrieve the most recent version of the cell
+ # for each column across entire row.
+ row_filter = bigtable.row_filters.CellsColumnLimitFilter(1)
+ # [END bigtable_hw_create_filter]
+
+ # [START bigtable_hw_get_with_filter]
+ # [START bigtable_hw_get_by_key]
+ print("Getting a single greeting by row key.")
+ key = b"greeting0"
+
+ row = table.read_row(key, row_filter)
+ cell = row.cells[column_family_id.decode("utf-8")][column][0]
+ print(cell.value.decode("utf-8"))
+ # [END bigtable_hw_get_by_key]
+ # [END bigtable_hw_get_with_filter]
+
+ # [START bigtable_hw_scan_with_filter]
+ # [START bigtable_hw_scan_all]
+ print("Scanning for all greetings:")
+ partial_rows = table.read_rows(filter_=row_filter)
+
+ for row in partial_rows:
+ column_family_id_str = column_family_id.decode("utf-8")
+ cell = row.cells[column_family_id_str][column][0]
+ print(cell.value.decode("utf-8"))
+ # [END bigtable_hw_scan_all]
+ # [END bigtable_hw_scan_with_filter]
+
+ finally:
+ # [START bigtable_hw_delete_table]
+ print("Deleting the {} table.".format(table_id))
+ table.delete()
+ # [END bigtable_hw_delete_table]
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
+ )
+ parser.add_argument("project_id", help="Your Cloud Platform project ID.")
+ parser.add_argument(
+ "instance_id", help="ID of the Cloud Bigtable instance to connect to."
+ )
+ parser.add_argument(
+ "--table", help="Table to create and destroy.", default="Hello-Bigtable"
+ )
+
+ args = parser.parse_args()
+ main(args.project_id, args.instance_id, args.table)
diff --git a/packages/google-cloud-bigtable/samples/hello/main_test.py b/packages/google-cloud-bigtable/samples/hello/main_test.py
new file mode 100644
index 000000000000..28814d909d2c
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello/main_test.py
@@ -0,0 +1,35 @@
+# Copyright 2016 Google Inc.
+#
+# 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.
+
+import os
+import uuid
+
+from .main import main
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"hello-world-test-{str(uuid.uuid4())[:16]}"
+
+
+def test_main(capsys):
+ main(PROJECT, BIGTABLE_INSTANCE, TABLE_ID)
+
+ out, _ = capsys.readouterr()
+ assert "Creating the {} table.".format(TABLE_ID) in out
+ assert "Writing some greetings to the table." in out
+ assert "Getting a single greeting by row key." in out
+ assert "Hello World!" in out
+ assert "Scanning for all greetings" in out
+ assert "Hello Cloud Bigtable!" in out
+ assert "Deleting the {} table.".format(TABLE_ID) in out
diff --git a/packages/google-cloud-bigtable/samples/hello/noxfile.py b/packages/google-cloud-bigtable/samples/hello/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/hello/requirements-test.txt b/packages/google-cloud-bigtable/samples/hello/requirements-test.txt
new file mode 100644
index 000000000000..e079f8a6038d
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello/requirements-test.txt
@@ -0,0 +1 @@
+pytest
diff --git a/packages/google-cloud-bigtable/samples/hello/requirements.txt b/packages/google-cloud-bigtable/samples/hello/requirements.txt
new file mode 100644
index 000000000000..5113ca7f17bb
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello/requirements.txt
@@ -0,0 +1,2 @@
+google-cloud-bigtable==2.35.0
+google-cloud-core==2.5.0
diff --git a/packages/google-cloud-bigtable/samples/hello_happybase/README.md b/packages/google-cloud-bigtable/samples/hello_happybase/README.md
new file mode 100644
index 000000000000..fdbea4e63739
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello_happybase/README.md
@@ -0,0 +1,52 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a refererence for how to use this product.
+Samples, quickstarts, and other documentation are available at cloud.google.com.
+
+
+### Hello World using HappyBase
+
+This sample demonstrates using the Google Cloud Client Library HappyBase package, an implementation of the HappyBase API to connect to and interact with Cloud Bigtable. More information available at: https://cloud.google.com/bigtable/docs/samples-python-hello-happybase
+
+
+
+
+
+To run this sample:
+
+1. If this is your first time working with GCP products, you will need to set up [the Cloud SDK][cloud_sdk] or utilize [Google Cloud Shell][gcloud_shell]. This sample may [require authetication][authentication] and you will need to [enable billing][enable_billing].
+
+1. Make a fork of this repo and clone the branch locally, then navigate to the sample directory you want to use.
+
+1. Install the dependencies needed to run the samples.
+
+ pip install -r requirements.txt
+
+1. Run the sample using
+
+ python main.py
+
+
+
+usage: main.py [-h] [--table TABLE] project_id instance_id
Demonstrates how to connect to Cloud Bigtable and run some basic operations.
Prerequisites: - Create a Cloud Bigtable cluster.
https://cloud.google.com/bigtable/docs/creating-cluster - Set your Google
Application Default Credentials.
https://developers.google.com/identity/protocols/application-default-
credentials
positional arguments:
project_id Your Cloud Platform project ID.
instance_id ID of the Cloud Bigtable instance to connect to.
optional arguments:
-h, --help show this help message and exit
--table TABLE Table to create and destroy. (default: Hello-Bigtable)
+
+## Additional Information
+
+You can read the documentation for more details on API usage and use GitHub
+to browse the source and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/hello_happybase/__init__.py b/packages/google-cloud-bigtable/samples/hello_happybase/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/hello_happybase/main.py b/packages/google-cloud-bigtable/samples/hello_happybase/main.py
new file mode 100644
index 000000000000..54099a1fa630
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello_happybase/main.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+
+# Copyright 2016 Google Inc.
+#
+# 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.
+
+"""Demonstrates how to connect to Cloud Bigtable and run some basic operations.
+
+Prerequisites:
+
+- Create a Cloud Bigtable cluster.
+ https://cloud.google.com/bigtable/docs/creating-cluster
+- Set your Google Application Default Credentials.
+ https://developers.google.com/identity/protocols/application-default-credentials
+"""
+
+import argparse
+
+# [START bigtable_hw_imports_happybase]
+from google.cloud import bigtable, happybase
+
+from ..utils import wait_for_table
+
+# [END bigtable_hw_imports_happybase]
+
+
+def main(project_id, instance_id, table_name):
+ # [START bigtable_hw_connect_happybase]
+ # The client must be created with admin=True because it will create a
+ # table.
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ connection = happybase.Connection(instance=instance)
+ # [END bigtable_hw_connect_happybase]
+
+ try:
+ # [START bigtable_hw_create_table_happybase]
+ print("Creating the {} table.".format(table_name))
+ column_family_name = "cf1"
+ connection.create_table(
+ table_name,
+ {column_family_name: dict()}, # Use default options.
+ )
+ # [END bigtable_hw_create_table_happybase]
+
+ wait_for_table(instance.table(table_name))
+
+ # [START bigtable_hw_write_rows_happybase]
+ print("Writing some greetings to the table.")
+ table = connection.table(table_name)
+ column_name = "{fam}:greeting".format(fam=column_family_name)
+ greetings = [
+ "Hello World!",
+ "Hello Cloud Bigtable!",
+ "Hello HappyBase!",
+ ]
+
+ for i, value in enumerate(greetings):
+ # Note: This example uses sequential numeric IDs for simplicity,
+ # but this can result in poor performance in a production
+ # application. Since rows are stored in sorted order by key,
+ # sequential keys can result in poor distribution of operations
+ # across nodes.
+ #
+ # For more information about how to design a Bigtable schema for
+ # the best performance, see the documentation:
+ #
+ # https://cloud.google.com/bigtable/docs/schema-design
+ row_key = "greeting{}".format(i)
+ table.put(row_key, {column_name.encode("utf-8"): value.encode("utf-8")})
+ # [END bigtable_hw_write_rows_happybase]
+
+ # [START bigtable_hw_get_by_key_happybase]
+ print("Getting a single greeting by row key.")
+ key = "greeting0".encode("utf-8")
+ row = table.row(key)
+ print("\t{}: {}".format(key, row[column_name.encode("utf-8")]))
+ # [END bigtable_hw_get_by_key_happybase]
+
+ # [START bigtable_hw_scan_all_happybase]
+ print("Scanning for all greetings:")
+
+ for key, row in table.scan():
+ print("\t{}: {}".format(key, row[column_name.encode("utf-8")]))
+ # [END bigtable_hw_scan_all_happybase]
+
+ finally:
+ # [START bigtable_hw_delete_table_happybase]
+ print("Deleting the {} table.".format(table_name))
+ connection.delete_table(table_name)
+ # [END bigtable_hw_delete_table_happybase]
+ connection.close()
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
+ )
+ parser.add_argument("project_id", help="Your Cloud Platform project ID.")
+ parser.add_argument(
+ "instance_id", help="ID of the Cloud Bigtable instance to connect to."
+ )
+ parser.add_argument(
+ "--table", help="Table to create and destroy.", default="Hello-Bigtable"
+ )
+
+ args = parser.parse_args()
+ main(args.project_id, args.instance_id, args.table)
diff --git a/packages/google-cloud-bigtable/samples/hello_happybase/main_test.py b/packages/google-cloud-bigtable/samples/hello_happybase/main_test.py
new file mode 100644
index 000000000000..b7c5ceea8ad9
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello_happybase/main_test.py
@@ -0,0 +1,45 @@
+# Copyright 2016 Google Inc.
+#
+# 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.
+
+import os
+import uuid
+
+from google.cloud import bigtable
+
+from .main import main
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"hello-world-hb-test-{str(uuid.uuid4())[:16]}"
+
+
+def test_main(capsys):
+ try:
+ main(PROJECT, BIGTABLE_INSTANCE, TABLE_ID)
+
+ out, _ = capsys.readouterr()
+ assert "Creating the {} table.".format(TABLE_ID) in out
+ assert "Writing some greetings to the table." in out
+ assert "Getting a single greeting by row key." in out
+ assert "Hello World!" in out
+ assert "Scanning for all greetings" in out
+ assert "Hello Cloud Bigtable!" in out
+ assert "Deleting the {} table.".format(TABLE_ID) in out
+ finally:
+ # delete table
+ client = bigtable.Client(PROJECT, admin=True)
+ instance = client.instance(BIGTABLE_INSTANCE)
+ table = instance.table(TABLE_ID)
+ if table.exists():
+ table.delete()
diff --git a/packages/google-cloud-bigtable/samples/hello_happybase/noxfile.py b/packages/google-cloud-bigtable/samples/hello_happybase/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello_happybase/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/hello_happybase/requirements-test.txt b/packages/google-cloud-bigtable/samples/hello_happybase/requirements-test.txt
new file mode 100644
index 000000000000..e079f8a6038d
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello_happybase/requirements-test.txt
@@ -0,0 +1 @@
+pytest
diff --git a/packages/google-cloud-bigtable/samples/hello_happybase/requirements.txt b/packages/google-cloud-bigtable/samples/hello_happybase/requirements.txt
new file mode 100644
index 000000000000..dc1a04f30378
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/hello_happybase/requirements.txt
@@ -0,0 +1,2 @@
+google-cloud-happybase==0.33.0
+six==1.17.0 # See https://github.com/googleapis/google-cloud-python-happybase/issues/128
diff --git a/packages/google-cloud-bigtable/samples/instanceadmin/README.md b/packages/google-cloud-bigtable/samples/instanceadmin/README.md
new file mode 100644
index 000000000000..675add700e93
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/instanceadmin/README.md
@@ -0,0 +1,52 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a refererence for how to use this product.
+Samples, quickstarts, and other documentation are available at cloud.google.com.
+
+
+### cbt Command Demonstration
+
+This page explains how to use the cbt command to connect to a Cloud Bigtable instance, perform basic administrative tasks, and read and write data in a table. More information about this quickstart is available at https://cloud.google.com/bigtable/docs/quickstart-cbt
+
+
+
+
+
+To run this sample:
+
+1. If this is your first time working with GCP products, you will need to set up [the Cloud SDK][cloud_sdk] or utilize [Google Cloud Shell][gcloud_shell]. This sample may [require authetication][authentication] and you will need to [enable billing][enable_billing].
+
+1. Make a fork of this repo and clone the branch locally, then navigate to the sample directory you want to use.
+
+1. Install the dependencies needed to run the samples.
+
+ pip install -r requirements.txt
+
+1. Run the sample using
+
+ python instanceadmin.py
+
+
+
+usage: instanceadmin.py [-h] [run] [dev-instance] [del-instance] [add-cluster] [del-cluster] project_id instance_id cluster_id
Demonstrates how to connect to Cloud Bigtable and run some basic operations.
Prerequisites: - Create a Cloud Bigtable cluster.
https://cloud.google.com/bigtable/docs/creating-cluster - Set your Google
Application Default Credentials.
https://developers.google.com/identity/protocols/application-default-
credentials
positional arguments:
project_id Your Cloud Platform project ID.
instance_id ID of the Cloud Bigtable instance to connect to.
optional arguments:
-h, --help show this help message and exit
--table TABLE Table to create and destroy. (default: Hello-Bigtable)
+
+## Additional Information
+
+You can read the documentation for more details on API usage and use GitHub
+to browse the source and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/instanceadmin/instanceadmin.py b/packages/google-cloud-bigtable/samples/instanceadmin/instanceadmin.py
new file mode 100644
index 000000000000..7341bfc46f19
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/instanceadmin/instanceadmin.py
@@ -0,0 +1,232 @@
+#!/usr/bin/env python
+
+# Copyright 2018, 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.
+
+"""Demonstrates how to connect to Cloud Bigtable and run some basic operations.
+# http://www.apache.org/licenses/LICENSE-2.0
+Prerequisites:
+- Create a Cloud Bigtable project.
+ https://cloud.google.com/bigtable/docs/
+- Set your Google Application Default Credentials.
+ https://developers.google.com/identity/protocols/application-default-credentials
+
+Operations performed:
+- Create a Cloud Bigtable Instance.
+- List Instance for a Cloud Bigtable.
+- Delete a Cloud Bigtable Instance.
+- Create a Cloud Bigtable Cluster.
+- List Cloud Bigtable Clusters.
+- Delete a Cloud Bigtable Cluster.
+"""
+
+import argparse
+
+from google.cloud import bigtable
+from google.cloud.bigtable import enums
+
+
+def run_instance_operations(project_id, instance_id, cluster_id):
+ """Check Instance exists.
+ Creates a Production instance with default Cluster.
+ List instances in a project.
+ List clusters in an instance.
+
+ :type project_id: str
+ :param project_id: Project id of the client.
+
+ :type instance_id: str
+ :param instance_id: Instance of the client.
+ """
+ client = bigtable.Client(project=project_id, admin=True)
+ location_id = "us-central1-f"
+ serve_nodes = 1
+ storage_type = enums.StorageType.SSD
+ labels = {"prod-label": "prod-label"}
+ instance = client.instance(instance_id, labels=labels)
+
+ # [START bigtable_check_instance_exists]
+ if not instance.exists():
+ print("Instance {} does not exist.".format(instance_id))
+ else:
+ print("Instance {} already exists.".format(instance_id))
+ # [END bigtable_check_instance_exists]
+
+ # [START bigtable_create_prod_instance]
+ cluster = instance.cluster(
+ cluster_id,
+ location_id=location_id,
+ serve_nodes=serve_nodes,
+ default_storage_type=storage_type,
+ )
+ if not instance.exists():
+ print("\nCreating an instance")
+ # Create instance with given options
+ operation = instance.create(clusters=[cluster])
+ # Ensure the operation completes.
+ operation.result(timeout=480)
+ print("\nCreated instance: {}".format(instance_id))
+ # [END bigtable_create_prod_instance]
+
+ # [START bigtable_list_instances]
+ print("\nListing instances:")
+ for instance_local in client.list_instances()[0]:
+ print(instance_local.instance_id)
+ # [END bigtable_list_instances]
+
+ # [START bigtable_get_instance]
+ print(
+ "\nName of instance: {}\nLabels: {}".format(
+ instance.display_name, instance.labels
+ )
+ )
+ # [END bigtable_get_instance]
+
+ # [START bigtable_get_clusters]
+ print("\nListing clusters...")
+ for cluster in instance.list_clusters()[0]:
+ print(cluster.cluster_id)
+ # [END bigtable_get_clusters]
+
+
+def delete_instance(project_id, instance_id):
+ """Delete the Instance
+
+ :type project_id: str
+ :param project_id: Project id of the client.
+
+ :type instance_id: str
+ :param instance_id: Instance of the client.
+ """
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ # [START bigtable_delete_instance]
+ print("\nDeleting instance")
+ if not instance.exists():
+ print("Instance {} does not exist.".format(instance_id))
+ else:
+ instance.delete()
+ print("Deleted instance: {}".format(instance_id))
+ # [END bigtable_delete_instance]
+
+
+def add_cluster(project_id, instance_id, cluster_id):
+ """Add Cluster
+
+ :type project_id: str
+ :param project_id: Project id of the client.
+
+ :type instance_id: str
+ :param instance_id: Instance of the client.
+
+ :type cluster_id: str
+ :param cluster_id: Cluster id.
+ """
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+
+ location_id = "us-central1-a"
+ serve_nodes = 1
+ storage_type = enums.StorageType.SSD
+
+ if not instance.exists():
+ print("Instance {} does not exist.".format(instance_id))
+ else:
+ print("\nAdding cluster to instance {}".format(instance_id))
+ # [START bigtable_create_cluster]
+ print("\nListing clusters...")
+ for cluster in instance.list_clusters()[0]:
+ print(cluster.cluster_id)
+ cluster = instance.cluster(
+ cluster_id,
+ location_id=location_id,
+ serve_nodes=serve_nodes,
+ default_storage_type=storage_type,
+ )
+ if cluster.exists():
+ print("\nCluster not created, as {} already exists.".format(cluster_id))
+ else:
+ operation = cluster.create()
+ # Ensure the operation completes.
+ operation.result(timeout=480)
+ print("\nCluster created: {}".format(cluster_id))
+ # [END bigtable_create_cluster]
+
+
+def delete_cluster(project_id, instance_id, cluster_id):
+ """Delete the cluster
+
+ :type project_id: str
+ :param project_id: Project id of the client.
+
+ :type instance_id: str
+ :param instance_id: Instance of the client.
+
+ :type cluster_id: str
+ :param cluster_id: Cluster id.
+ """
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ cluster = instance.cluster(cluster_id)
+
+ # [START bigtable_delete_cluster]
+ print("\nDeleting cluster")
+ if cluster.exists():
+ cluster.delete()
+ print("Cluster deleted: {}".format(cluster_id))
+ else:
+ print("\nCluster {} does not exist.".format(cluster_id))
+
+ # [END bigtable_delete_cluster]
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
+ )
+
+ parser.add_argument(
+ "command",
+ help="run, del-instance, \
+ add-cluster or del-cluster. \
+ Operation to perform on Instance.",
+ )
+ parser.add_argument("project_id", help="Your Cloud Platform project ID.")
+ parser.add_argument(
+ "instance_id",
+ help="ID of the Cloud Bigtable instance to \
+ connect to.",
+ )
+ parser.add_argument(
+ "cluster_id",
+ help="ID of the Cloud Bigtable cluster to \
+ connect to.",
+ )
+
+ args = parser.parse_args()
+
+ if args.command.lower() == "run":
+ run_instance_operations(args.project_id, args.instance_id, args.cluster_id)
+ elif args.command.lower() == "del-instance":
+ delete_instance(args.project_id, args.instance_id)
+ elif args.command.lower() == "add-cluster":
+ add_cluster(args.project_id, args.instance_id, args.cluster_id)
+ elif args.command.lower() == "del-cluster":
+ delete_cluster(args.project_id, args.instance_id, args.cluster_id)
+ else:
+ print(
+ "Command should be either run \n Use argument -h, \
+ --help to show help and exit."
+ )
diff --git a/packages/google-cloud-bigtable/samples/instanceadmin/noxfile.py b/packages/google-cloud-bigtable/samples/instanceadmin/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/instanceadmin/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/instanceadmin/requirements-test.txt b/packages/google-cloud-bigtable/samples/instanceadmin/requirements-test.txt
new file mode 100644
index 000000000000..e079f8a6038d
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/instanceadmin/requirements-test.txt
@@ -0,0 +1 @@
+pytest
diff --git a/packages/google-cloud-bigtable/samples/instanceadmin/requirements.txt b/packages/google-cloud-bigtable/samples/instanceadmin/requirements.txt
new file mode 100644
index 000000000000..67a1ea5b8d23
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/instanceadmin/requirements.txt
@@ -0,0 +1,2 @@
+google-cloud-bigtable==2.35.0
+backoff==2.2.1
diff --git a/packages/google-cloud-bigtable/samples/instanceadmin/test_instanceadmin.py b/packages/google-cloud-bigtable/samples/instanceadmin/test_instanceadmin.py
new file mode 100644
index 000000000000..5d1378fcd946
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/instanceadmin/test_instanceadmin.py
@@ -0,0 +1,179 @@
+# Copyright 2018 Google Inc.
+#
+# 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.
+
+import os
+import random
+import time
+import warnings
+
+import backoff
+import instanceadmin
+import pytest
+from google.api_core import exceptions
+
+from google.cloud import bigtable
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+INSTANCE_ID_FORMAT = "instanceadmin-{:03}-{}"
+CLUSTER_ID_FORMAT = "instanceadmin-{:03}"
+ID_RANGE = 1000
+
+INSTANCE = INSTANCE_ID_FORMAT.format(random.randrange(ID_RANGE), int(time.time()))
+CLUSTER1 = CLUSTER_ID_FORMAT.format(random.randrange(ID_RANGE))
+CLUSTER2 = CLUSTER_ID_FORMAT.format(random.randrange(ID_RANGE))
+
+
+@pytest.fixture(scope="module", autouse=True)
+def preclean():
+ """In case any test instances weren't cleared out in a previous run.
+
+ Deletes any test instances that were created over an hour ago. Newer instances may
+ be being used by a concurrent test run.
+ """
+ client = bigtable.Client(project=PROJECT, admin=True)
+ for instance in client.list_instances()[0]:
+ if instance.instance_id.startswith("instanceadmin-"):
+ timestamp = instance.instance_id.split("-")[-1]
+ timestamp = int(timestamp)
+ if time.time() - timestamp > 3600:
+ warnings.warn(
+ f"Deleting leftover test instance: {instance.instance_id}"
+ )
+ instance.delete()
+
+
+@pytest.fixture
+def dispose_of():
+ instances = []
+
+ def disposal(instance):
+ instances.append(instance)
+
+ yield disposal
+
+ client = bigtable.Client(project=PROJECT, admin=True)
+ for instance_id in instances:
+ instance = client.instance(instance_id)
+ if instance.exists():
+ instance.delete()
+
+
+def test_run_instance_operations(capsys, dispose_of):
+ dispose_of(INSTANCE)
+
+ instanceadmin.run_instance_operations(PROJECT, INSTANCE, CLUSTER1)
+ out = capsys.readouterr().out
+ assert f"Instance {INSTANCE} does not exist." in out
+ assert "Creating an instance" in out
+ assert f"Created instance: {INSTANCE}" in out
+ assert "Listing instances" in out
+ assert f"\n{INSTANCE}\n" in out
+ assert f"Name of instance: {INSTANCE}" in out
+ assert "Labels: {'prod-label': 'prod-label'}" in out
+ assert "Listing clusters..." in out
+ assert f"\n{CLUSTER1}\n" in out
+
+ instanceadmin.run_instance_operations(PROJECT, INSTANCE, CLUSTER1)
+ out = capsys.readouterr().out
+ assert f"Instance {INSTANCE} already exists." in out
+ assert "Listing instances" in out
+ assert f"\n{INSTANCE}\n" in out
+ assert f"Name of instance: {INSTANCE}" in out
+ assert "Labels: {'prod-label': 'prod-label'}" in out
+ assert "Listing clusters..." in out
+ assert f"\n{CLUSTER1}\n" in out
+
+
+def test_delete_instance(capsys, dispose_of):
+ from concurrent.futures import TimeoutError
+
+ @backoff.on_exception(backoff.expo, TimeoutError)
+ def _set_up_instance():
+ dispose_of(INSTANCE)
+
+ # Can't delete it, it doesn't exist
+ instanceadmin.delete_instance(PROJECT, INSTANCE)
+ out = capsys.readouterr().out
+ assert "Deleting instance" in out
+ assert f"Instance {INSTANCE} does not exist" in out
+
+ # Ok, create it then
+ instanceadmin.run_instance_operations(PROJECT, INSTANCE, CLUSTER1)
+ capsys.readouterr() # throw away output
+
+ _set_up_instance()
+
+ # Now delete it
+ instanceadmin.delete_instance(PROJECT, INSTANCE)
+ out = capsys.readouterr().out
+ assert "Deleting instance" in out
+ assert f"Deleted instance: {INSTANCE}" in out
+
+
+def test_add_and_delete_cluster(capsys, dispose_of):
+ from concurrent.futures import TimeoutError
+
+ @backoff.on_exception(backoff.expo, TimeoutError)
+ def _set_up_instance():
+ dispose_of(INSTANCE)
+
+ # This won't work, because the instance isn't created yet
+ instanceadmin.add_cluster(PROJECT, INSTANCE, CLUSTER2)
+ out = capsys.readouterr().out
+ assert f"Instance {INSTANCE} does not exist" in out
+
+ # Get the instance created
+ instanceadmin.run_instance_operations(PROJECT, INSTANCE, CLUSTER1)
+ capsys.readouterr() # throw away output
+
+ _set_up_instance()
+
+ # Add a cluster to that instance
+ # Avoid failing for "instance is currently being changed" by
+ # applying an exponential backoff
+ backoff_503 = backoff.on_exception(backoff.expo, exceptions.ServiceUnavailable)
+
+ backoff_503(instanceadmin.add_cluster)(PROJECT, INSTANCE, CLUSTER2)
+ out = capsys.readouterr().out
+ assert f"Adding cluster to instance {INSTANCE}" in out
+ assert "Listing clusters..." in out
+ assert f"\n{CLUSTER1}\n" in out
+ assert f"Cluster created: {CLUSTER2}" in out
+
+ # Try to add the same cluster again, won't work
+ instanceadmin.add_cluster(PROJECT, INSTANCE, CLUSTER2)
+ out = capsys.readouterr().out
+ assert "Listing clusters..." in out
+ assert f"\n{CLUSTER1}\n" in out
+ assert f"\n{CLUSTER2}\n" in out
+ assert f"Cluster not created, as {CLUSTER2} already exists."
+
+ # Now delete it
+ instanceadmin.delete_cluster(PROJECT, INSTANCE, CLUSTER2)
+ out = capsys.readouterr().out
+ assert "Deleting cluster" in out
+ assert f"Cluster deleted: {CLUSTER2}" in out
+
+ # Verify deletion
+ instanceadmin.run_instance_operations(PROJECT, INSTANCE, CLUSTER1)
+ out = capsys.readouterr().out
+ assert "Listing clusters..." in out
+ assert f"\n{CLUSTER1}\n" in out
+ assert f"\n{CLUSTER2}\n" not in out
+
+ # Try deleting it again, for fun (and coverage)
+ instanceadmin.delete_cluster(PROJECT, INSTANCE, CLUSTER2)
+ out = capsys.readouterr().out
+ assert "Deleting cluster" in out
+ assert f"Cluster {CLUSTER2} does not exist" in out
diff --git a/packages/google-cloud-bigtable/samples/metricscaler/Dockerfile b/packages/google-cloud-bigtable/samples/metricscaler/Dockerfile
new file mode 100644
index 000000000000..d8a5ec0c1a9b
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/metricscaler/Dockerfile
@@ -0,0 +1,24 @@
+# Copyright 2020 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.
+FROM python:3
+
+WORKDIR /usr/src/app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENTRYPOINT [ "python", "./metricscaler.py"]
+CMD ["--help"]
diff --git a/packages/google-cloud-bigtable/samples/metricscaler/README.md b/packages/google-cloud-bigtable/samples/metricscaler/README.md
new file mode 100644
index 000000000000..e1624bb1872e
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/metricscaler/README.md
@@ -0,0 +1,52 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a refererence for how to use this product.
+Samples, quickstarts, and other documentation are available at cloud.google.com.
+
+
+### Metric Scaler
+
+This sample demonstrates how to use Stackdriver Monitoring to scale Cloud Bigtable based on CPU usage.
+
+
+
+
+
+To run this sample:
+
+1. If this is your first time working with GCP products, you will need to set up [the Cloud SDK][cloud_sdk] or utilize [Google Cloud Shell][gcloud_shell]. This sample may [require authetication][authentication] and you will need to [enable billing][enable_billing].
+
+1. Make a fork of this repo and clone the branch locally, then navigate to the sample directory you want to use.
+
+1. Install the dependencies needed to run the samples.
+
+ pip install -r requirements.txt
+
+1. Run the sample using
+
+ python metricscaler.py
+
+
+
+usage: metricscaler.py [-h] [--high_cpu_threshold HIGH_CPU_THRESHOLD] [--low_cpu_threshold LOW_CPU_THRESHOLD] [--short_sleep SHORT_SLEEP] [--long_sleep LONG_SLEEP] bigtable_instance bigtable_cluster
usage: metricscaler.py [-h] [--high_cpu_threshold HIGH_CPU_THRESHOLD]
[--low_cpu_threshold LOW_CPU_THRESHOLD]
[--short_sleep SHORT_SLEEP] [--long_sleep LONG_SLEEP]
bigtable_instance bigtable_cluster
Scales Cloud Bigtable clusters based on CPU usage.
positional arguments:
bigtable_instance ID of the Cloud Bigtable instance to connect to.
bigtable_cluster ID of the Cloud Bigtable cluster to connect to.
optional arguments:
-h, --help show this help message and exit
--high_cpu_threshold HIGH_CPU_THRESHOLD
If Cloud Bigtable CPU usage is above this threshold,
scale up
--low_cpu_threshold LOW_CPU_THRESHOLD
If Cloud Bigtable CPU usage is below this threshold,
scale down
--short_sleep SHORT_SLEEP
How long to sleep in seconds between checking metrics
after no scale operation
--long_sleep LONG_SLEEP
How long to sleep in seconds between checking metrics
after a scaling operation
+
+## Additional Information
+
+You can read the documentation for more details on API usage and use GitHub
+to browse the source and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/metricscaler/metricscaler.py b/packages/google-cloud-bigtable/samples/metricscaler/metricscaler.py
new file mode 100644
index 000000000000..1f89e6aacc15
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/metricscaler/metricscaler.py
@@ -0,0 +1,234 @@
+# Copyright 2017 Google Inc.
+#
+# 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.
+
+"""Sample that demonstrates how to use Stackdriver Monitoring metrics to
+programmatically scale a Google Cloud Bigtable cluster."""
+
+import argparse
+import logging
+import os
+import time
+
+from google.cloud.monitoring_v3 import query
+
+from google.cloud import bigtable, monitoring_v3
+from google.cloud.bigtable import enums
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+
+logger = logging.getLogger("bigtable.metricscaler")
+logger.addHandler(logging.StreamHandler())
+logger.setLevel(logging.INFO)
+
+
+def get_cpu_load(bigtable_instance, bigtable_cluster):
+ """Returns the most recent Cloud Bigtable CPU load measurement.
+
+ Returns:
+ float: The most recent Cloud Bigtable CPU usage metric
+ """
+ # [START bigtable_cpu]
+ client = monitoring_v3.MetricServiceClient()
+ cpu_query = query.Query(
+ client,
+ project=PROJECT,
+ metric_type="bigtable.googleapis.com/cluster/cpu_load",
+ minutes=5,
+ )
+ cpu_query = cpu_query.select_resources(
+ instance=bigtable_instance, cluster=bigtable_cluster
+ )
+ cpu = next(cpu_query.iter())
+ return cpu.points[0].value.double_value
+ # [END bigtable_cpu]
+
+
+def get_storage_utilization(bigtable_instance, bigtable_cluster):
+ """Returns the most recent Cloud Bigtable storage utilization measurement.
+
+ Returns:
+ float: The most recent Cloud Bigtable storage utilization metric
+ """
+ # [START bigtable_metric_scaler_storage_utilization]
+ client = monitoring_v3.MetricServiceClient()
+ utilization_query = query.Query(
+ client,
+ project=PROJECT,
+ metric_type="bigtable.googleapis.com/cluster/storage_utilization",
+ minutes=5,
+ )
+ utilization_query = utilization_query.select_resources(
+ instance=bigtable_instance, cluster=bigtable_cluster
+ )
+ utilization = next(utilization_query.iter())
+ return utilization.points[0].value.double_value
+ # [END bigtable_metric_scaler_storage_utilization]
+
+
+def scale_bigtable(bigtable_instance, bigtable_cluster, scale_up):
+ """Scales the number of Cloud Bigtable nodes up or down.
+
+ Edits the number of nodes in the Cloud Bigtable cluster to be increased
+ or decreased, depending on the `scale_up` boolean argument. Currently
+ the `incremental` strategy from `strategies.py` is used.
+
+
+ Args:
+ bigtable_instance (str): Cloud Bigtable instance ID to scale
+ bigtable_cluster (str): Cloud Bigtable cluster ID to scale
+ scale_up (bool): If true, scale up, otherwise scale down
+ """
+
+ # The minimum number of nodes to use. The default minimum is 3. If you have
+ # a lot of data, the rule of thumb is to not go below 2.5 TB per node for
+ # SSD lusters, and 8 TB for HDD. The
+ # "bigtable.googleapis.com/disk/bytes_used" metric is useful in figuring
+ # out the minimum number of nodes.
+ min_node_count = 1
+
+ # The maximum number of nodes to use. The default maximum is 30 nodes per
+ # zone. If you need more quota, you can request more by following the
+ # instructions at https://cloud.google.com/bigtable/quota.
+ max_node_count = 30
+
+ # The number of nodes to change the cluster by.
+ size_change_step = 3
+
+ # [START bigtable_scale]
+ bigtable_client = bigtable.Client(admin=True)
+ instance = bigtable_client.instance(bigtable_instance)
+ instance.reload()
+
+ if instance.type_ == enums.Instance.Type.DEVELOPMENT:
+ raise ValueError("Development instances cannot be scaled.")
+
+ cluster = instance.cluster(bigtable_cluster)
+ cluster.reload()
+
+ current_node_count = cluster.serve_nodes
+
+ if scale_up:
+ if current_node_count < max_node_count:
+ new_node_count = min(current_node_count + size_change_step, max_node_count)
+ cluster.serve_nodes = new_node_count
+ operation = cluster.update()
+ response = operation.result(480)
+ logger.info(
+ "Scaled up from {} to {} nodes for {}.".format(
+ current_node_count, new_node_count, response.name
+ )
+ )
+ else:
+ if current_node_count > min_node_count:
+ new_node_count = max(current_node_count - size_change_step, min_node_count)
+ cluster.serve_nodes = new_node_count
+ operation = cluster.update()
+ response = operation.result(480)
+ logger.info(
+ "Scaled down from {} to {} nodes for {}.".format(
+ current_node_count, new_node_count, response.name
+ )
+ )
+ # [END bigtable_scale]
+
+
+def main(
+ bigtable_instance,
+ bigtable_cluster,
+ high_cpu_threshold,
+ low_cpu_threshold,
+ high_storage_threshold,
+ short_sleep,
+ long_sleep,
+):
+ """Main loop runner that autoscales Cloud Bigtable.
+
+ Args:
+ bigtable_instance (str): Cloud Bigtable instance ID to autoscale
+ high_cpu_threshold (float): If CPU is higher than this, scale up.
+ low_cpu_threshold (float): If CPU is lower than this, scale down.
+ high_storage_threshold (float): If storage is higher than this,
+ scale up.
+ short_sleep (int): How long to sleep after no operation
+ long_sleep (int): How long to sleep after the number of nodes is
+ changed
+ """
+ cluster_cpu = get_cpu_load(bigtable_instance, bigtable_cluster)
+ cluster_storage = get_storage_utilization(bigtable_instance, bigtable_cluster)
+ logger.info("Detected cpu of {}".format(cluster_cpu))
+ logger.info("Detected storage utilization of {}".format(cluster_storage))
+ try:
+ if cluster_cpu > high_cpu_threshold or cluster_storage > high_storage_threshold:
+ scale_bigtable(bigtable_instance, bigtable_cluster, True)
+ time.sleep(long_sleep)
+ elif cluster_cpu < low_cpu_threshold:
+ if cluster_storage < high_storage_threshold:
+ scale_bigtable(bigtable_instance, bigtable_cluster, False)
+ time.sleep(long_sleep)
+ else:
+ logger.info("CPU within threshold, sleeping.")
+ time.sleep(short_sleep)
+ except Exception as e:
+ logger.error("Error during scaling: %s", e)
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description="Scales Cloud Bigtable clusters based on CPU usage."
+ )
+ parser.add_argument(
+ "bigtable_instance", help="ID of the Cloud Bigtable instance to connect to."
+ )
+ parser.add_argument(
+ "bigtable_cluster", help="ID of the Cloud Bigtable cluster to connect to."
+ )
+ parser.add_argument(
+ "--high_cpu_threshold",
+ help="If Cloud Bigtable CPU usage is above this threshold, scale up",
+ default=0.6,
+ )
+ parser.add_argument(
+ "--low_cpu_threshold",
+ help="If Cloud Bigtable CPU usage is below this threshold, scale down",
+ default=0.2,
+ )
+ parser.add_argument(
+ "--high_storage_threshold",
+ help="If Cloud Bigtable storage utilization is above this threshold, scale up",
+ default=0.6,
+ )
+ parser.add_argument(
+ "--short_sleep",
+ help="How long to sleep in seconds between checking metrics after no "
+ "scale operation",
+ default=60,
+ )
+ parser.add_argument(
+ "--long_sleep",
+ help="How long to sleep in seconds between checking metrics after a "
+ "scaling operation",
+ default=60 * 10,
+ )
+ args = parser.parse_args()
+
+ while True:
+ main(
+ args.bigtable_instance,
+ args.bigtable_cluster,
+ float(args.high_cpu_threshold),
+ float(args.low_cpu_threshold),
+ float(args.high_storage_threshold),
+ int(args.short_sleep),
+ int(args.long_sleep),
+ )
diff --git a/packages/google-cloud-bigtable/samples/metricscaler/metricscaler_test.py b/packages/google-cloud-bigtable/samples/metricscaler/metricscaler_test.py
new file mode 100644
index 000000000000..f769ce05e11f
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/metricscaler/metricscaler_test.py
@@ -0,0 +1,225 @@
+# Copyright 2017 Google Inc.
+#
+# 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.
+
+"""Unit and system tests for metricscaler.py"""
+
+import os
+import uuid
+
+import pytest
+from metricscaler import get_cpu_load, get_storage_utilization, main, scale_bigtable
+from mock import Mock, patch
+from test_utils.retry import RetryInstanceState, RetryResult
+
+from google.cloud import bigtable
+from google.cloud.bigtable import enums
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_ZONE = os.environ["BIGTABLE_ZONE"]
+SIZE_CHANGE_STEP = 3
+INSTANCE_ID_FORMAT = "metric-scale-test-{}"
+BIGTABLE_INSTANCE = INSTANCE_ID_FORMAT.format(str(uuid.uuid4())[:10])
+BIGTABLE_DEV_INSTANCE = INSTANCE_ID_FORMAT.format(str(uuid.uuid4())[:10])
+
+
+# System tests to verify API calls succeed
+
+
+@patch("metricscaler.query")
+def test_get_cpu_load(monitoring_v3_query):
+ iter_mock = monitoring_v3_query.Query().select_resources().iter
+ iter_mock.return_value = iter([Mock(points=[Mock(value=Mock(double_value=1.0))])])
+ assert float(get_cpu_load(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE)) > 0.0
+
+
+@patch("metricscaler.query")
+def test_get_storage_utilization(monitoring_v3_query):
+ iter_mock = monitoring_v3_query.Query().select_resources().iter
+ iter_mock.return_value = iter([Mock(points=[Mock(value=Mock(double_value=1.0))])])
+ assert float(get_storage_utilization(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE)) > 0.0
+
+
+@pytest.fixture()
+def instance():
+ cluster_id = BIGTABLE_INSTANCE
+
+ client = bigtable.Client(project=PROJECT, admin=True)
+
+ serve_nodes = 1
+ storage_type = enums.StorageType.SSD
+ production = enums.Instance.Type.PRODUCTION
+ labels = {"prod-label": "prod-label"}
+ instance = client.instance(
+ BIGTABLE_INSTANCE, instance_type=production, labels=labels
+ )
+
+ if not instance.exists():
+ cluster = instance.cluster(
+ cluster_id,
+ location_id=BIGTABLE_ZONE,
+ serve_nodes=serve_nodes,
+ default_storage_type=storage_type,
+ )
+ operation = instance.create(clusters=[cluster])
+ response = operation.result(480)
+ print(f"Successfully created {response.name}")
+
+ # Eventual consistency check
+ retry_found = RetryResult(bool)
+ retry_found(instance.exists)()
+
+ yield
+
+ instance.delete()
+
+
+@pytest.fixture()
+def dev_instance():
+ cluster_id = BIGTABLE_DEV_INSTANCE
+
+ client = bigtable.Client(project=PROJECT, admin=True)
+
+ storage_type = enums.StorageType.SSD
+ development = enums.Instance.Type.DEVELOPMENT
+ labels = {"dev-label": "dev-label"}
+ instance = client.instance(
+ BIGTABLE_DEV_INSTANCE, instance_type=development, labels=labels
+ )
+
+ if not instance.exists():
+ cluster = instance.cluster(
+ cluster_id, location_id=BIGTABLE_ZONE, default_storage_type=storage_type
+ )
+ operation = instance.create(clusters=[cluster])
+ response = operation.result(480)
+ print(f"Successfully created {response.name}")
+
+ # Eventual consistency check
+ retry_found = RetryResult(bool)
+ retry_found(instance.exists)()
+
+ yield
+
+ instance.delete()
+
+
+class ClusterNodeCountPredicate:
+ def __init__(self, expected_node_count):
+ self.expected_node_count = expected_node_count
+
+ def __call__(self, cluster):
+ expected = self.expected_node_count
+ print(f"Expected node count: {expected}; found: {cluster.serve_nodes}")
+ return cluster.serve_nodes == expected
+
+
+def test_scale_bigtable(instance):
+ bigtable_client = bigtable.Client(admin=True)
+
+ instance = bigtable_client.instance(BIGTABLE_INSTANCE)
+ instance.reload()
+
+ cluster = instance.cluster(BIGTABLE_INSTANCE)
+
+ _nonzero_node_count = RetryInstanceState(
+ instance_predicate=lambda c: c.serve_nodes > 0,
+ max_tries=10,
+ )
+ _nonzero_node_count(cluster.reload)()
+
+ original_node_count = cluster.serve_nodes
+
+ scale_bigtable(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, True)
+
+ scaled_node_count_predicate = ClusterNodeCountPredicate(
+ original_node_count + SIZE_CHANGE_STEP
+ )
+ scaled_node_count_predicate.__name__ = "scaled_node_count_predicate"
+ _scaled_node_count = RetryInstanceState(
+ instance_predicate=scaled_node_count_predicate,
+ max_tries=10,
+ )
+ _scaled_node_count(cluster.reload)()
+
+ scale_bigtable(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, False)
+
+ restored_node_count_predicate = ClusterNodeCountPredicate(original_node_count)
+ restored_node_count_predicate.__name__ = "restored_node_count_predicate"
+ _restored_node_count = RetryInstanceState(
+ instance_predicate=restored_node_count_predicate,
+ max_tries=10,
+ )
+ _restored_node_count(cluster.reload)()
+
+
+def test_handle_dev_instance(capsys, dev_instance):
+ with pytest.raises(ValueError):
+ scale_bigtable(BIGTABLE_DEV_INSTANCE, BIGTABLE_DEV_INSTANCE, True)
+
+
+@patch("time.sleep")
+@patch("metricscaler.get_storage_utilization")
+@patch("metricscaler.get_cpu_load")
+@patch("metricscaler.scale_bigtable")
+def test_main(scale_bigtable, get_cpu_load, get_storage_utilization, sleep):
+ SHORT_SLEEP = 5
+ LONG_SLEEP = 10
+
+ # Test okay CPU, okay storage utilization
+ get_cpu_load.return_value = 0.5
+ get_storage_utilization.return_value = 0.5
+
+ main(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, 0.6, 0.3, 0.6, SHORT_SLEEP, LONG_SLEEP)
+ scale_bigtable.assert_not_called()
+ scale_bigtable.reset_mock()
+
+ # Test high CPU, okay storage utilization
+ get_cpu_load.return_value = 0.7
+ get_storage_utilization.return_value = 0.5
+ main(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, 0.6, 0.3, 0.6, SHORT_SLEEP, LONG_SLEEP)
+ scale_bigtable.assert_called_once_with(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, True)
+ scale_bigtable.reset_mock()
+
+ # Test low CPU, okay storage utilization
+ get_storage_utilization.return_value = 0.5
+ get_cpu_load.return_value = 0.2
+ main(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, 0.6, 0.3, 0.6, SHORT_SLEEP, LONG_SLEEP)
+ scale_bigtable.assert_called_once_with(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, False)
+ scale_bigtable.reset_mock()
+
+ # Test okay CPU, high storage utilization
+ get_cpu_load.return_value = 0.5
+ get_storage_utilization.return_value = 0.7
+
+ main(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, 0.6, 0.3, 0.6, SHORT_SLEEP, LONG_SLEEP)
+ scale_bigtable.assert_called_once_with(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, True)
+ scale_bigtable.reset_mock()
+
+ # Test high CPU, high storage utilization
+ get_cpu_load.return_value = 0.7
+ get_storage_utilization.return_value = 0.7
+ main(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, 0.6, 0.3, 0.6, SHORT_SLEEP, LONG_SLEEP)
+ scale_bigtable.assert_called_once_with(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, True)
+ scale_bigtable.reset_mock()
+
+ # Test low CPU, high storage utilization
+ get_cpu_load.return_value = 0.2
+ get_storage_utilization.return_value = 0.7
+ main(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, 0.6, 0.3, 0.6, SHORT_SLEEP, LONG_SLEEP)
+ scale_bigtable.assert_called_once_with(BIGTABLE_INSTANCE, BIGTABLE_INSTANCE, True)
+ scale_bigtable.reset_mock()
+
+
+if __name__ == "__main__":
+ test_get_cpu_load()
diff --git a/packages/google-cloud-bigtable/samples/metricscaler/noxfile.py b/packages/google-cloud-bigtable/samples/metricscaler/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/metricscaler/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/metricscaler/noxfile_config.py b/packages/google-cloud-bigtable/samples/metricscaler/noxfile_config.py
new file mode 100644
index 000000000000..8a2d55bea291
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/metricscaler/noxfile_config.py
@@ -0,0 +1,39 @@
+# Copyright 2021 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.
+
+# Default TEST_CONFIG_OVERRIDE for python repos.
+
+# You can copy this file into your directory, then it will be imported from
+# the noxfile.py.
+
+# The source of truth:
+# https://github.com/GoogleCloudPlatform/python-docs-samples/blob/main/noxfile_config.py
+
+TEST_CONFIG_OVERRIDE = {
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "BUILD_SPECIFIC_GCLOUD_PROJECT",
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
diff --git a/packages/google-cloud-bigtable/samples/metricscaler/requirements-test.txt b/packages/google-cloud-bigtable/samples/metricscaler/requirements-test.txt
new file mode 100644
index 000000000000..d11108b81f7c
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/metricscaler/requirements-test.txt
@@ -0,0 +1,3 @@
+pytest
+mock==5.2.0
+google-cloud-testutils
diff --git a/packages/google-cloud-bigtable/samples/metricscaler/requirements.txt b/packages/google-cloud-bigtable/samples/metricscaler/requirements.txt
new file mode 100644
index 000000000000..257fd1ef67aa
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/metricscaler/requirements.txt
@@ -0,0 +1,2 @@
+google-cloud-bigtable==2.35.0
+google-cloud-monitoring==2.29.0
diff --git a/packages/google-cloud-bigtable/samples/quickstart/README.md b/packages/google-cloud-bigtable/samples/quickstart/README.md
new file mode 100644
index 000000000000..f61000e135d0
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart/README.md
@@ -0,0 +1,52 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a refererence for how to use this product.
+Samples, quickstarts, and other documentation are available at cloud.google.com.
+
+
+### Quickstart
+
+Demonstrates of Cloud Bigtable. This sample creates a Bigtable client, connects to an instance and then to a table, then closes the connection.
+
+
+
+
+
+To run this sample:
+
+1. If this is your first time working with GCP products, you will need to set up [the Cloud SDK][cloud_sdk] or utilize [Google Cloud Shell][gcloud_shell]. This sample may [require authetication][authentication] and you will need to [enable billing][enable_billing].
+
+1. Make a fork of this repo and clone the branch locally, then navigate to the sample directory you want to use.
+
+1. Install the dependencies needed to run the samples.
+
+ pip install -r requirements.txt
+
+1. Run the sample using
+
+ python main.py
+
+
+
+usage: main.py [-h] [--table TABLE] project_id instance_id
positional arguments:
project_id Your Cloud Platform project ID.
instance_id ID of the Cloud Bigtable instance to connect to.
optional arguments:
-h, --help show this help message and exit
--table TABLE Existing table used in the quickstart. (default: my-table)
+
+## Additional Information
+
+You can read the documentation for more details on API usage and use GitHub
+to browse the source and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/quickstart/__init__.py b/packages/google-cloud-bigtable/samples/quickstart/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/quickstart/main.py b/packages/google-cloud-bigtable/samples/quickstart/main.py
new file mode 100644
index 000000000000..50bfe639426c
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart/main.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+# Copyright 2018 Google Inc.
+#
+# 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.
+
+# [START bigtable_quickstart]
+import argparse
+
+from google.cloud import bigtable
+
+
+def main(project_id="project-id", instance_id="instance-id", table_id="my-table"):
+ # Create a Cloud Bigtable client.
+ client = bigtable.Client(project=project_id)
+
+ # Connect to an existing Cloud Bigtable instance.
+ instance = client.instance(instance_id)
+
+ # Open an existing table.
+ table = instance.table(table_id)
+
+ row_key = "r1"
+ row = table.read_row(row_key.encode("utf-8"))
+
+ column_family_id = "cf1"
+ column_id = "c1".encode("utf-8")
+ value = row.cells[column_family_id][column_id][0].value.decode("utf-8")
+
+ print("Row key: {}\nData: {}".format(row_key, value))
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
+ )
+ parser.add_argument("project_id", help="Your Cloud Platform project ID.")
+ parser.add_argument(
+ "instance_id", help="ID of the Cloud Bigtable instance to connect to."
+ )
+ parser.add_argument(
+ "--table", help="Existing table used in the quickstart.", default="my-table"
+ )
+
+ args = parser.parse_args()
+ main(args.project_id, args.instance_id, args.table)
+# [END bigtable_quickstart]
diff --git a/packages/google-cloud-bigtable/samples/quickstart/main_async.py b/packages/google-cloud-bigtable/samples/quickstart/main_async.py
new file mode 100644
index 000000000000..c38985592e42
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart/main_async.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+# Copyright 2024 Google Inc.
+#
+# 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.
+
+# [START bigtable_quickstart_asyncio]
+import argparse
+import asyncio
+
+from google.cloud.bigtable.data import BigtableDataClientAsync
+
+
+async def main(project_id="project-id", instance_id="instance-id", table_id="my-table"):
+ # Create a Cloud Bigtable client.
+ client = BigtableDataClientAsync(project=project_id)
+
+ # Open an existing table.
+ table = client.get_table(instance_id, table_id)
+
+ row_key = "r1"
+ row = await table.read_row(row_key)
+
+ column_family_id = "cf1"
+ column_id = b"c1"
+ value = row.get_cells(column_family_id, column_id)[0].value.decode("utf-8")
+
+ await table.close()
+ await client.close()
+
+ print("Row key: {}\nData: {}".format(row_key, value))
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
+ )
+ parser.add_argument("project_id", help="Your Cloud Platform project ID.")
+ parser.add_argument(
+ "instance_id", help="ID of the Cloud Bigtable instance to connect to."
+ )
+ parser.add_argument(
+ "--table", help="Existing table used in the quickstart.", default="my-table"
+ )
+
+ args = parser.parse_args()
+ asyncio.get_event_loop().run_until_complete(
+ main(args.project_id, args.instance_id, args.table)
+ )
+
+# [END bigtable_quickstart_asyncio]
diff --git a/packages/google-cloud-bigtable/samples/quickstart/main_async_test.py b/packages/google-cloud-bigtable/samples/quickstart/main_async_test.py
new file mode 100644
index 000000000000..a67c0d095ba0
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart/main_async_test.py
@@ -0,0 +1,50 @@
+# Copyright 2024 Google Inc.
+#
+# 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.
+
+import os
+import uuid
+from typing import AsyncGenerator
+
+import pytest
+import pytest_asyncio
+
+from google.cloud.bigtable.data import BigtableDataClientAsync, SetCell
+
+from ..utils import create_table_cm
+from .main_async import main
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"quickstart-async-test-{str(uuid.uuid4())[:16]}"
+
+
+@pytest_asyncio.fixture
+async def table_id() -> AsyncGenerator[str, None]:
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"cf1": None}):
+ await _populate_table(TABLE_ID)
+ yield TABLE_ID
+
+
+async def _populate_table(table_id: str):
+ async with BigtableDataClientAsync(project=PROJECT) as client:
+ async with client.get_table(BIGTABLE_INSTANCE, table_id) as table:
+ await table.mutate_row("r1", SetCell("cf1", "c1", "test-value"))
+
+
+@pytest.mark.asyncio
+async def test_main(capsys, table_id):
+ await main(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ assert "Row key: r1\nData: test-value\n" in out
diff --git a/packages/google-cloud-bigtable/samples/quickstart/main_test.py b/packages/google-cloud-bigtable/samples/quickstart/main_test.py
new file mode 100644
index 000000000000..88419abd7ec4
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart/main_test.py
@@ -0,0 +1,47 @@
+# Copyright 2018 Google Inc.
+#
+# 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.
+
+import os
+import uuid
+
+import pytest
+
+from ..utils import create_table_cm
+from .main import main
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"quickstart-test-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture()
+def table():
+ column_family_id = "cf1"
+ column_families = {column_family_id: None}
+ with create_table_cm(
+ PROJECT, BIGTABLE_INSTANCE, TABLE_ID, column_families
+ ) as table:
+ row = table.direct_row("r1")
+ row.set_cell(column_family_id, "c1", "test-value")
+ row.commit()
+
+ yield TABLE_ID
+
+
+def test_main(capsys, table):
+ table_id = table
+ main(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ assert "Row key: r1\nData: test-value\n" in out
diff --git a/packages/google-cloud-bigtable/samples/quickstart/noxfile.py b/packages/google-cloud-bigtable/samples/quickstart/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/quickstart/requirements-test.txt b/packages/google-cloud-bigtable/samples/quickstart/requirements-test.txt
new file mode 100644
index 000000000000..ee4ba018603b
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart/requirements-test.txt
@@ -0,0 +1,2 @@
+pytest
+pytest-asyncio
diff --git a/packages/google-cloud-bigtable/samples/quickstart/requirements.txt b/packages/google-cloud-bigtable/samples/quickstart/requirements.txt
new file mode 100644
index 000000000000..730d25dec63f
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart/requirements.txt
@@ -0,0 +1 @@
+google-cloud-bigtable==2.35.0
diff --git a/packages/google-cloud-bigtable/samples/quickstart_happybase/README.md b/packages/google-cloud-bigtable/samples/quickstart_happybase/README.md
new file mode 100644
index 000000000000..6d4d8871e3cb
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart_happybase/README.md
@@ -0,0 +1,52 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a refererence for how to use this product.
+Samples, quickstarts, and other documentation are available at cloud.google.com.
+
+
+### Quickstart using HappyBase
+
+Demonstrates of Cloud Bigtable using HappyBase. This sample creates a Bigtable client, connects to an instance and then to a table, then closes the connection.
+
+
+
+
+
+To run this sample:
+
+1. If this is your first time working with GCP products, you will need to set up [the Cloud SDK][cloud_sdk] or utilize [Google Cloud Shell][gcloud_shell]. This sample may [require authetication][authentication] and you will need to [enable billing][enable_billing].
+
+1. Make a fork of this repo and clone the branch locally, then navigate to the sample directory you want to use.
+
+1. Install the dependencies needed to run the samples.
+
+ pip install -r requirements.txt
+
+1. Run the sample using
+
+ python main.py
+
+
+
+usage: main.py [-h] [--table TABLE] project_id instance_id
usage: main.py [-h] [--table TABLE] project_id instance_id
positional arguments:
project_id Your Cloud Platform project ID.
instance_id ID of the Cloud Bigtable instance to connect to.
optional arguments:
-h, --help show this help message and exit
--table TABLE Existing table used in the quickstart. (default: my-table)browse the source and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/quickstart_happybase/__init__.py b/packages/google-cloud-bigtable/samples/quickstart_happybase/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/quickstart_happybase/main.py b/packages/google-cloud-bigtable/samples/quickstart_happybase/main.py
new file mode 100644
index 000000000000..6e474d141201
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart_happybase/main.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+# Copyright 2018 Google Inc.
+#
+# 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.
+# [START bigtable_quickstart_happybase]
+import argparse
+
+from google.cloud import bigtable, happybase
+
+
+def main(project_id="project-id", instance_id="instance-id", table_id="my-table"):
+ # Creates a Bigtable client
+ client = bigtable.Client(project=project_id)
+
+ # Connect to an existing instance:my-bigtable-instance
+ instance = client.instance(instance_id)
+
+ connection = happybase.Connection(instance=instance)
+
+ try:
+ # Connect to an existing table:my-table
+ table = connection.table(table_id)
+
+ key = "r1"
+ row = table.row(key.encode("utf-8"))
+
+ column = "cf1:c1".encode("utf-8")
+ value = row[column].decode("utf-8")
+ print("Row key: {}\nData: {}".format(key, value))
+
+ finally:
+ connection.close()
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
+ )
+ parser.add_argument("project_id", help="Your Cloud Platform project ID.")
+ parser.add_argument(
+ "instance_id", help="ID of the Cloud Bigtable instance to connect to."
+ )
+ parser.add_argument(
+ "--table", help="Existing table used in the quickstart.", default="my-table"
+ )
+
+ args = parser.parse_args()
+ main(args.project_id, args.instance_id, args.table)
+# [END bigtable_quickstart_happybase]
diff --git a/packages/google-cloud-bigtable/samples/quickstart_happybase/main_test.py b/packages/google-cloud-bigtable/samples/quickstart_happybase/main_test.py
new file mode 100644
index 000000000000..0f0d1ecf5f5f
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart_happybase/main_test.py
@@ -0,0 +1,47 @@
+# Copyright 2018 Google Inc.
+#
+# 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.
+
+import os
+import uuid
+
+import pytest
+
+from ..utils import create_table_cm
+from .main import main
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"quickstart-hb-test-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture()
+def table():
+ column_family_id = "cf1"
+ column_families = {column_family_id: None}
+ with create_table_cm(
+ PROJECT, BIGTABLE_INSTANCE, TABLE_ID, column_families
+ ) as table:
+ row = table.direct_row("r1")
+ row.set_cell(column_family_id, "c1", "test-value")
+ row.commit()
+
+ yield TABLE_ID
+
+
+def test_main(capsys, table):
+ table_id = table
+ main(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ assert "Row key: r1\nData: test-value\n" in out
diff --git a/packages/google-cloud-bigtable/samples/quickstart_happybase/noxfile.py b/packages/google-cloud-bigtable/samples/quickstart_happybase/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart_happybase/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/quickstart_happybase/requirements-test.txt b/packages/google-cloud-bigtable/samples/quickstart_happybase/requirements-test.txt
new file mode 100644
index 000000000000..55b033e901cd
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart_happybase/requirements-test.txt
@@ -0,0 +1 @@
+pytest
\ No newline at end of file
diff --git a/packages/google-cloud-bigtable/samples/quickstart_happybase/requirements.txt b/packages/google-cloud-bigtable/samples/quickstart_happybase/requirements.txt
new file mode 100644
index 000000000000..dc1a04f30378
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/quickstart_happybase/requirements.txt
@@ -0,0 +1,2 @@
+google-cloud-happybase==0.33.0
+six==1.17.0 # See https://github.com/googleapis/google-cloud-python-happybase/issues/128
diff --git a/packages/google-cloud-bigtable/samples/snippets/README.md b/packages/google-cloud-bigtable/samples/snippets/README.md
new file mode 100644
index 000000000000..7c0dd4463214
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/README.md
@@ -0,0 +1,33 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a reference for how to use this product.
+Samples, quickstarts, and other documentation are available at [cloud.google.com](https://cloud.google.com/bigtable).
+
+
+### Snippets
+
+This folder contains snippets for Python Cloud Bigtable.
+
+
+
+
+## Additional Information
+
+You can read the documentation for more details on API usage and use GitHub
+to [browse the source](https://github.com/googleapis/python-bigtable) and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/snippets/__init__.py b/packages/google-cloud-bigtable/samples/snippets/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/snippets/data_client/__init__.py b/packages/google-cloud-bigtable/samples/snippets/data_client/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/snippets/data_client/data_client_snippets_async.py b/packages/google-cloud-bigtable/samples/snippets/data_client/data_client_snippets_async.py
new file mode 100644
index 000000000000..2d5a7e39521a
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/data_client/data_client_snippets_async.py
@@ -0,0 +1,315 @@
+#!/usr/bin/env python
+
+# Copyright 2024, 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.
+
+
+async def write_simple(table):
+ # [START bigtable_async_write_simple]
+ from google.cloud.bigtable.data import BigtableDataClientAsync, SetCell
+
+ async def write_simple(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ family_id = "stats_summary"
+ row_key = b"phone#4c410523#20190501"
+
+ cell_mutation = SetCell(family_id, "connected_cell", 1)
+ wifi_mutation = SetCell(family_id, "connected_wifi", 1)
+ os_mutation = SetCell(family_id, "os_build", "PQ2A.190405.003")
+
+ await table.mutate_row(row_key, cell_mutation)
+ await table.mutate_row(row_key, wifi_mutation)
+ await table.mutate_row(row_key, os_mutation)
+
+ # [END bigtable_async_write_simple]
+ await write_simple(table.client.project, table.instance_id, table.table_id)
+
+
+async def write_batch(table):
+ # [START bigtable_async_writes_batch]
+ from google.cloud.bigtable.data import BigtableDataClientAsync
+ from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
+ from google.cloud.bigtable.data.mutations import RowMutationEntry, SetCell
+
+ async def write_batch(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ family_id = "stats_summary"
+ try:
+ async with table.mutations_batcher() as batcher:
+ mutation_list = [
+ SetCell(family_id, "connected_cell", 1),
+ SetCell(family_id, "connected_wifi", 1),
+ SetCell(family_id, "os_build", "12155.0.0-rc1"),
+ ]
+ # awaiting the batcher.append method adds the RowMutationEntry
+ # to the batcher's queue to be written in the next flush.
+ await batcher.append(
+ RowMutationEntry("tablet#a0b81f74#20190501", mutation_list)
+ )
+ await batcher.append(
+ RowMutationEntry("tablet#a0b81f74#20190502", mutation_list)
+ )
+ except MutationsExceptionGroup as e:
+ # MutationsExceptionGroup contains a FailedMutationEntryError for
+ # each mutation that failed.
+ for sub_exception in e.exceptions:
+ failed_entry: RowMutationEntry = sub_exception.entry
+ cause: Exception = sub_exception.__cause__
+ print(
+ f"Failed mutation: {failed_entry.row_key} with error: {cause!r}"
+ )
+
+ # [END bigtable_async_writes_batch]
+ await write_batch(table.client.project, table.instance_id, table.table_id)
+
+
+async def write_increment(table):
+ # [START bigtable_async_write_increment]
+ from google.cloud.bigtable.data import BigtableDataClientAsync
+ from google.cloud.bigtable.data.read_modify_write_rules import IncrementRule
+
+ async def write_increment(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ family_id = "stats_summary"
+ row_key = "phone#4c410523#20190501"
+
+ # Decrement the connected_wifi value by 1.
+ increment_rule = IncrementRule(
+ family_id, "connected_wifi", increment_amount=-1
+ )
+ result_row = await table.read_modify_write_row(row_key, increment_rule)
+
+ # check result
+ cell = result_row[0]
+ print(f"{cell.row_key} value: {int(cell)}")
+
+ # [END bigtable_async_write_increment]
+ await write_increment(table.client.project, table.instance_id, table.table_id)
+
+
+async def write_conditional(table):
+ # [START bigtable_async_writes_conditional]
+ from google.cloud.bigtable.data import BigtableDataClientAsync, SetCell, row_filters
+
+ async def write_conditional(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ family_id = "stats_summary"
+ row_key = "phone#4c410523#20190501"
+
+ row_filter = row_filters.RowFilterChain(
+ filters=[
+ row_filters.FamilyNameRegexFilter(family_id),
+ row_filters.ColumnQualifierRegexFilter("os_build"),
+ row_filters.ValueRegexFilter("PQ2A\\..*"),
+ ]
+ )
+
+ if_true = SetCell(family_id, "os_name", "android")
+ result = await table.check_and_mutate_row(
+ row_key,
+ row_filter,
+ true_case_mutations=if_true,
+ false_case_mutations=None,
+ )
+ if result is True:
+ print("The row os_name was set to android")
+
+ # [END bigtable_async_writes_conditional]
+ await write_conditional(table.client.project, table.instance_id, table.table_id)
+
+
+async def write_aggregate(table):
+ # [START bigtable_async_write_aggregate]
+ import time
+
+ from google.cloud.bigtable.data import BigtableDataClientAsync
+ from google.cloud.bigtable.data.exceptions import MutationsExceptionGroup
+ from google.cloud.bigtable.data.mutations import AddToCell, RowMutationEntry
+
+ async def write_aggregate(project_id, instance_id, table_id):
+ """Increments a value in a Bigtable table using AddToCell mutation."""
+ async with BigtableDataClientAsync(project=project_id) as client:
+ table = client.get_table(instance_id, table_id)
+ row_key = "unique_device_ids_1"
+ try:
+ async with table.mutations_batcher() as batcher:
+ # The AddToCell mutation increments the value of a cell.
+ # The `counters` family must be set up to be an aggregate
+ # family with an int64 input type.
+ reading = AddToCell(
+ family="counters",
+ qualifier="odometer",
+ value=32304,
+ # Convert nanoseconds to microseconds
+ timestamp_micros=time.time_ns() // 1000,
+ )
+ await batcher.append(
+ RowMutationEntry(row_key.encode("utf-8"), [reading])
+ )
+ except MutationsExceptionGroup as e:
+ # MutationsExceptionGroup contains a FailedMutationEntryError for
+ # each mutation that failed.
+ for sub_exception in e.exceptions:
+ failed_entry: RowMutationEntry = sub_exception.entry
+ cause: Exception = sub_exception.__cause__
+ print(
+ f"Failed mutation for row {failed_entry.row_key!r} with error: {cause!r}"
+ )
+
+ # [END bigtable_async_write_aggregate]
+ await write_aggregate(table.client.project, table.instance_id, table.table_id)
+
+
+async def read_row(table):
+ # [START bigtable_async_reads_row]
+ from google.cloud.bigtable.data import BigtableDataClientAsync
+
+ async def read_row(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ row_key = "phone#4c410523#20190501"
+ row = await table.read_row(row_key)
+ print(row)
+
+ # [END bigtable_async_reads_row]
+ await read_row(table.client.project, table.instance_id, table.table_id)
+
+
+async def read_row_partial(table):
+ # [START bigtable_async_reads_row_partial]
+ from google.cloud.bigtable.data import BigtableDataClientAsync, row_filters
+
+ async def read_row_partial(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ row_key = "phone#4c410523#20190501"
+ col_filter = row_filters.ColumnQualifierRegexFilter(b"os_build")
+
+ row = await table.read_row(row_key, row_filter=col_filter)
+ print(row)
+
+ # [END bigtable_async_reads_row_partial]
+ await read_row_partial(table.client.project, table.instance_id, table.table_id)
+
+
+async def read_rows_multiple(table):
+ # [START bigtable_async_reads_rows]
+ from google.cloud.bigtable.data import BigtableDataClientAsync, ReadRowsQuery
+
+ async def read_rows(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ query = ReadRowsQuery(
+ row_keys=[b"phone#4c410523#20190501", b"phone#4c410523#20190502"]
+ )
+ async for row in await table.read_rows_stream(query):
+ print(row)
+
+ # [END bigtable_async_reads_rows]
+ await read_rows(table.client.project, table.instance_id, table.table_id)
+
+
+async def read_row_range(table):
+ # [START bigtable_async_reads_row_range]
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ RowRange,
+ )
+
+ async def read_row_range(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ row_range = RowRange(
+ start_key=b"phone#4c410523#20190501",
+ end_key=b"phone#4c410523#201906201",
+ )
+ query = ReadRowsQuery(row_ranges=[row_range])
+
+ async for row in await table.read_rows_stream(query):
+ print(row)
+
+ # [END bigtable_async_reads_row_range]
+ await read_row_range(table.client.project, table.instance_id, table.table_id)
+
+
+async def read_with_prefix(table):
+ # [START bigtable_async_reads_prefix]
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ RowRange,
+ )
+
+ async def read_prefix(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ prefix = "phone#"
+ end_key = prefix[:-1] + chr(ord(prefix[-1]) + 1)
+ prefix_range = RowRange(start_key=prefix, end_key=end_key)
+ query = ReadRowsQuery(row_ranges=[prefix_range])
+
+ async for row in await table.read_rows_stream(query):
+ print(row)
+
+ # [END bigtable_async_reads_prefix]
+ await read_prefix(table.client.project, table.instance_id, table.table_id)
+
+
+async def read_with_filter(table):
+ # [START bigtable_async_reads_filter]
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ async def read_with_filter(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ row_filter = row_filters.ValueRegexFilter(b"PQ2A.*$")
+ query = ReadRowsQuery(row_filter=row_filter)
+
+ async for row in await table.read_rows_stream(query):
+ print(row)
+
+ # [END bigtable_async_reads_filter]
+ await read_with_filter(table.client.project, table.instance_id, table.table_id)
+
+
+async def execute_query(table):
+ # [START bigtable_async_execute_query]
+ from google.cloud.bigtable.data import BigtableDataClientAsync
+
+ async def execute_query(project_id, instance_id, table_id):
+ async with BigtableDataClientAsync(project=project_id) as client:
+ query = (
+ "SELECT _key, stats_summary['os_build'], "
+ "stats_summary['connected_cell'], "
+ "stats_summary['connected_wifi'] "
+ f"from `{table_id}` WHERE _key=@row_key"
+ )
+ result = await client.execute_query(
+ query,
+ instance_id,
+ parameters={"row_key": b"phone#4c410523#20190501"},
+ )
+ results = [r async for r in result]
+ print(results)
+
+ # [END bigtable_async_execute_query]
+ await execute_query(table.client.project, table.instance_id, table.table_id)
diff --git a/packages/google-cloud-bigtable/samples/snippets/data_client/data_client_snippets_async_test.py b/packages/google-cloud-bigtable/samples/snippets/data_client/data_client_snippets_async_test.py
new file mode 100644
index 000000000000..6742d2260a83
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/data_client/data_client_snippets_async_test.py
@@ -0,0 +1,117 @@
+# Copyright 2024, 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.
+import os
+import uuid
+
+import pytest
+import pytest_asyncio
+
+from ...utils import create_table_cm
+from . import data_client_snippets_async as data_snippets
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"data-client-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture(scope="session")
+def column_family_config():
+ from google.cloud.bigtable_admin_v2 import types
+
+ int_aggregate_type = types.Type.Aggregate(
+ input_type=types.Type(int64_type={"encoding": {"big_endian_bytes": {}}}),
+ sum={},
+ )
+
+ return {
+ "family": types.ColumnFamily(),
+ "stats_summary": types.ColumnFamily(),
+ "counters": types.ColumnFamily(
+ value_type=types.Type(aggregate_type=int_aggregate_type)
+ ),
+ }
+
+
+@pytest.fixture(scope="session")
+def table_id(column_family_config):
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, column_family_config):
+ yield TABLE_ID
+
+
+@pytest_asyncio.fixture
+async def table(table_id):
+ from google.cloud.bigtable.data import BigtableDataClientAsync
+
+ async with BigtableDataClientAsync(project=PROJECT) as client:
+ async with client.get_table(BIGTABLE_INSTANCE, table_id) as table:
+ yield table
+
+
+@pytest.mark.asyncio
+async def test_write_simple(table):
+ await data_snippets.write_simple(table)
+
+
+@pytest.mark.asyncio
+async def test_write_batch(table):
+ await data_snippets.write_batch(table)
+
+
+@pytest.mark.asyncio
+async def test_write_increment(table):
+ await data_snippets.write_increment(table)
+
+
+@pytest.mark.asyncio
+async def test_write_conditional(table):
+ await data_snippets.write_conditional(table)
+
+
+@pytest.mark.asyncio
+async def test_write_aggregate(table):
+ await data_snippets.write_aggregate(table)
+
+
+@pytest.mark.asyncio
+async def test_read_row(table):
+ await data_snippets.read_row(table)
+
+
+@pytest.mark.asyncio
+async def test_read_row_partial(table):
+ await data_snippets.read_row_partial(table)
+
+
+@pytest.mark.asyncio
+async def test_read_rows_multiple(table):
+ await data_snippets.read_rows_multiple(table)
+
+
+@pytest.mark.asyncio
+async def test_read_row_range(table):
+ await data_snippets.read_row_range(table)
+
+
+@pytest.mark.asyncio
+async def test_read_with_prefix(table):
+ await data_snippets.read_with_prefix(table)
+
+
+@pytest.mark.asyncio
+async def test_read_with_filter(table):
+ await data_snippets.read_with_filter(table)
+
+
+@pytest.mark.asyncio
+async def test_execute_query(table):
+ await data_snippets.execute_query(table)
diff --git a/packages/google-cloud-bigtable/samples/snippets/data_client/noxfile.py b/packages/google-cloud-bigtable/samples/snippets/data_client/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/data_client/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/snippets/data_client/requirements-test.txt b/packages/google-cloud-bigtable/samples/snippets/data_client/requirements-test.txt
new file mode 100644
index 000000000000..ee4ba018603b
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/data_client/requirements-test.txt
@@ -0,0 +1,2 @@
+pytest
+pytest-asyncio
diff --git a/packages/google-cloud-bigtable/samples/snippets/data_client/requirements.txt b/packages/google-cloud-bigtable/samples/snippets/data_client/requirements.txt
new file mode 100644
index 000000000000..730d25dec63f
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/data_client/requirements.txt
@@ -0,0 +1 @@
+google-cloud-bigtable==2.35.0
diff --git a/packages/google-cloud-bigtable/samples/snippets/deletes/__init__.py b/packages/google-cloud-bigtable/samples/snippets/deletes/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_async_test.py b/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_async_test.py
new file mode 100644
index 000000000000..f5e93995cff9
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_async_test.py
@@ -0,0 +1,281 @@
+# Copyright 2024, 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.
+
+
+import datetime
+import os
+import uuid
+from typing import AsyncGenerator
+
+import pytest
+import pytest_asyncio
+from google.cloud._helpers import _microseconds_from_datetime
+
+from ...utils import create_table_cm
+from . import deletes_snippets_async
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"mobile-time-series-deletes-async-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture(scope="module")
+def event_loop():
+ import asyncio
+
+ loop = asyncio.get_event_loop_policy().new_event_loop()
+ yield loop
+ loop.close()
+
+
+@pytest_asyncio.fixture(scope="module", autouse=True)
+async def table_id() -> AsyncGenerator[str, None]:
+ with create_table_cm(
+ PROJECT,
+ BIGTABLE_INSTANCE,
+ TABLE_ID,
+ {"stats_summary": None, "cell_plan": None},
+ verbose=False,
+ ):
+ await _populate_table(TABLE_ID)
+ yield TABLE_ID
+
+
+async def _populate_table(table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ RowMutationEntry,
+ SetCell,
+ )
+
+ timestamp = datetime.datetime(2019, 5, 1)
+ timestamp_minus_hr = timestamp - datetime.timedelta(hours=1)
+
+ async with BigtableDataClientAsync(project=PROJECT) as client:
+ async with client.get_table(BIGTABLE_INSTANCE, table_id) as table:
+ async with table.mutations_batcher() as batcher:
+ await batcher.append(
+ RowMutationEntry(
+ "phone#4c410523#20190501",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190405.003",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_01gb",
+ "true",
+ _microseconds_from_datetime(timestamp_minus_hr),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_01gb",
+ "false",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_05gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+ await batcher.append(
+ RowMutationEntry(
+ "phone#4c410523#20190502",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190405.004",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_05gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+ await batcher.append(
+ RowMutationEntry(
+ "phone#4c410523#20190505",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 0,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190406.000",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_05gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+ await batcher.append(
+ RowMutationEntry(
+ "phone#5c10102#20190501",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190401.002",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_10gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+ await batcher.append(
+ RowMutationEntry(
+ "phone#5c10102#20190502",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 0,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190406.000",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_10gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+
+
+def assert_output_match(capsys, expected):
+ out, _ = capsys.readouterr()
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_delete_from_column(capsys, table_id):
+ await deletes_snippets_async.delete_from_column(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+ assert_output_match(capsys, "")
+
+
+@pytest.mark.asyncio
+async def test_delete_from_column_family(capsys, table_id):
+ await deletes_snippets_async.delete_from_column_family(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+ assert_output_match(capsys, "")
+
+
+@pytest.mark.asyncio
+async def test_delete_from_row(capsys, table_id):
+ await deletes_snippets_async.delete_from_row(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
+
+
+@pytest.mark.asyncio
+async def test_streaming_and_batching(capsys, table_id):
+ await deletes_snippets_async.streaming_and_batching(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+ assert_output_match(capsys, "")
+
+
+@pytest.mark.asyncio
+async def test_check_and_mutate(capsys, table_id):
+ await deletes_snippets_async.check_and_mutate(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
diff --git a/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_snippets.py b/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_snippets.py
new file mode 100644
index 000000000000..09f467577732
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_snippets.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+
+# Copyright 2022, 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.
+
+
+# [START bigtable_delete_from_column]
+def delete_from_column(project_id, instance_id, table_id):
+ from google.cloud.bigtable import Client
+
+ client = Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ row = table.row("phone#4c410523#20190501")
+ row.delete_cell(column_family_id="cell_plan", column="data_plan_01gb")
+ row.commit()
+
+
+# [END bigtable_delete_from_column]
+
+
+# [START bigtable_delete_from_column_family]
+def delete_from_column_family(project_id, instance_id, table_id):
+ from google.cloud.bigtable import Client
+
+ client = Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ row = table.row("phone#4c410523#20190501")
+ row.delete_cells(column_family_id="cell_plan", columns=row.ALL_COLUMNS)
+ row.commit()
+
+
+# [END bigtable_delete_from_column_family]
+
+
+# [START bigtable_delete_from_row]
+def delete_from_row(project_id, instance_id, table_id):
+ from google.cloud.bigtable import Client
+
+ client = Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ row = table.row("phone#4c410523#20190501")
+ row.delete()
+ row.commit()
+
+
+# [END bigtable_delete_from_row]
+
+
+# [START bigtable_streaming_and_batching]
+def streaming_and_batching(project_id, instance_id, table_id):
+ from google.cloud.bigtable import Client
+
+ client = Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ batcher = table.mutations_batcher(flush_count=2)
+ rows = table.read_rows()
+ for row in rows:
+ row = table.row(row.row_key)
+ row.delete_cell(column_family_id="cell_plan", column="data_plan_01gb")
+
+ batcher.mutate_rows(rows)
+
+
+# [END bigtable_streaming_and_batching]
+
+
+# [START bigtable_check_and_mutate]
+def check_and_mutate(project_id, instance_id, table_id):
+ from google.cloud.bigtable import Client
+
+ client = Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ row = table.row("phone#4c410523#20190501")
+ row.delete_cell(column_family_id="cell_plan", column="data_plan_01gb")
+ row.delete_cell(column_family_id="cell_plan", column="data_plan_05gb")
+ row.commit()
+
+
+# [END bigtable_check_and_mutate]
+
+
+# [START bigtable_drop_row_range]
+def drop_row_range(project_id, instance_id, table_id):
+ from google.cloud.bigtable import Client
+
+ client = Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ row_key_prefix = "phone#4c410523"
+ table.drop_by_prefix(row_key_prefix, timeout=200)
+
+
+# [END bigtable_drop_row_range]
+
+
+# [START bigtable_delete_column_family]
+def delete_column_family(project_id, instance_id, table_id):
+ from google.cloud.bigtable import Client
+
+ client = Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ column_family_id = "stats_summary"
+ column_family_obj = table.column_family(column_family_id)
+ column_family_obj.delete()
+
+
+# [END bigtable_delete_column_family]
+
+
+# [START bigtable_delete_table]
+def delete_table(project_id, instance_id, table_id):
+ from google.cloud.bigtable import Client
+
+ client = Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ table.delete()
+
+
+# [END bigtable_delete_table]
diff --git a/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_snippets_async.py b/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_snippets_async.py
new file mode 100644
index 000000000000..b70d557e7610
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_snippets_async.py
@@ -0,0 +1,124 @@
+#!/usr/bin/env python
+
+# Copyright 2024, 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.
+
+
+# [START bigtable_delete_from_column_asyncio]
+async def delete_from_column(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ DeleteRangeFromColumn,
+ )
+
+ client = BigtableDataClientAsync(project=project_id)
+ table = client.get_table(instance_id, table_id)
+
+ await table.mutate_row(
+ "phone#4c410523#20190501",
+ DeleteRangeFromColumn(family="cell_plan", qualifier=b"data_plan_01gb"),
+ )
+
+ await table.close()
+ await client.close()
+
+
+# [END bigtable_delete_from_column_asyncio]
+
+
+# [START bigtable_delete_from_column_family_asyncio]
+async def delete_from_column_family(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import BigtableDataClientAsync, DeleteAllFromFamily
+
+ client = BigtableDataClientAsync(project=project_id)
+ table = client.get_table(instance_id, table_id)
+
+ await table.mutate_row("phone#4c410523#20190501", DeleteAllFromFamily("cell_plan"))
+
+ await table.close()
+ await client.close()
+
+
+# [END bigtable_delete_from_column_family_asyncio]
+
+
+# [START bigtable_delete_from_row_asyncio]
+async def delete_from_row(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import BigtableDataClientAsync, DeleteAllFromRow
+
+ client = BigtableDataClientAsync(project=project_id)
+ table = client.get_table(instance_id, table_id)
+
+ await table.mutate_row("phone#4c410523#20190501", DeleteAllFromRow())
+
+ await table.close()
+ await client.close()
+
+
+# [END bigtable_delete_from_row_asyncio]
+
+
+# [START bigtable_streaming_and_batching_asyncio]
+async def streaming_and_batching(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ DeleteRangeFromColumn,
+ ReadRowsQuery,
+ RowMutationEntry,
+ )
+
+ client = BigtableDataClientAsync(project=project_id)
+ table = client.get_table(instance_id, table_id)
+
+ async with table.mutations_batcher() as batcher:
+ async for row in await table.read_rows_stream(ReadRowsQuery(limit=10)):
+ await batcher.append(
+ RowMutationEntry(
+ row.row_key,
+ DeleteRangeFromColumn(
+ family="cell_plan", qualifier=b"data_plan_01gb"
+ ),
+ )
+ )
+
+ await table.close()
+ await client.close()
+
+
+# [END bigtable_streaming_and_batching_asyncio]
+
+
+# [START bigtable_check_and_mutate_asyncio]
+async def check_and_mutate(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ DeleteRangeFromColumn,
+ )
+ from google.cloud.bigtable.data.row_filters import LiteralValueFilter
+
+ client = BigtableDataClientAsync(project=project_id)
+ table = client.get_table(instance_id, table_id)
+
+ await table.check_and_mutate_row(
+ "phone#4c410523#20190501",
+ predicate=LiteralValueFilter("PQ2A.190405.003"),
+ true_case_mutations=DeleteRangeFromColumn(
+ family="cell_plan", qualifier=b"data_plan_01gb"
+ ),
+ )
+
+ await table.close()
+ await client.close()
+
+
+# [END bigtable_check_and_mutate_asyncio]
diff --git a/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_test.py b/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_test.py
new file mode 100644
index 000000000000..a683df541309
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/deletes/deletes_test.py
@@ -0,0 +1,139 @@
+# Copyright 2020, 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.
+
+
+import datetime
+import os
+import time
+import uuid
+
+import pytest
+
+from ...utils import create_table_cm
+from . import deletes_snippets
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"mobile-time-series-deletes-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture(scope="module")
+def table_id():
+ from google.cloud.bigtable.row_set import RowSet
+
+ with create_table_cm(
+ PROJECT,
+ BIGTABLE_INSTANCE,
+ TABLE_ID,
+ {"stats_summary": None, "cell_plan": None},
+ verbose=False,
+ ) as table:
+ timestamp = datetime.datetime(2019, 5, 1)
+ timestamp_minus_hr = datetime.datetime(2019, 5, 1) - datetime.timedelta(hours=1)
+
+ row_keys = [
+ "phone#4c410523#20190501",
+ "phone#4c410523#20190502",
+ "phone#4c410523#20190505",
+ "phone#5c10102#20190501",
+ "phone#5c10102#20190502",
+ ]
+
+ rows = [table.direct_row(row_key) for row_key in row_keys]
+
+ rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
+ rows[0].set_cell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr)
+ rows[0].set_cell("cell_plan", "data_plan_01gb", "false", timestamp)
+ rows[0].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
+ rows[1].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
+ rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[2].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
+ rows[3].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
+ rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
+ rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[4].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
+
+ table.mutate_rows(rows)
+
+ # Ensure mutations have propagated.
+ row_set = RowSet()
+
+ for row_key in row_keys:
+ row_set.add_row_key(row_key)
+
+ fetched = list(table.read_rows(row_set=row_set))
+
+ while len(fetched) < len(rows):
+ time.sleep(5)
+ fetched = list(table.read_rows(row_set=row_set))
+
+ yield TABLE_ID
+
+
+def assert_output_match(capsys, expected):
+ out, _ = capsys.readouterr()
+ assert out == expected
+
+
+def test_delete_from_column(capsys, table_id):
+ deletes_snippets.delete_from_column(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
+
+
+def test_delete_from_column_family(capsys, table_id):
+ deletes_snippets.delete_from_column_family(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
+
+
+def test_delete_from_row(capsys, table_id):
+ deletes_snippets.delete_from_row(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
+
+
+def test_streaming_and_batching(capsys, table_id):
+ deletes_snippets.streaming_and_batching(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
+
+
+def test_check_and_mutate(capsys, table_id):
+ deletes_snippets.check_and_mutate(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
+
+
+def test_drop_row_range(capsys, table_id):
+ deletes_snippets.drop_row_range(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
+
+
+def test_delete_column_family(capsys, table_id):
+ deletes_snippets.delete_column_family(PROJECT, BIGTABLE_INSTANCE, table_id)
+ assert_output_match(capsys, "")
+
+
+def test_delete_table(capsys):
+ delete_table_id = f"to-delete-table-{str(uuid.uuid4())[:16]}"
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, delete_table_id, verbose=False):
+ deletes_snippets.delete_table(PROJECT, BIGTABLE_INSTANCE, delete_table_id)
+ assert_output_match(capsys, "")
diff --git a/packages/google-cloud-bigtable/samples/snippets/deletes/noxfile.py b/packages/google-cloud-bigtable/samples/snippets/deletes/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/deletes/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/snippets/deletes/requirements-test.txt b/packages/google-cloud-bigtable/samples/snippets/deletes/requirements-test.txt
new file mode 100644
index 000000000000..ee4ba018603b
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/deletes/requirements-test.txt
@@ -0,0 +1,2 @@
+pytest
+pytest-asyncio
diff --git a/packages/google-cloud-bigtable/samples/snippets/deletes/requirements.txt b/packages/google-cloud-bigtable/samples/snippets/deletes/requirements.txt
new file mode 100644
index 000000000000..730d25dec63f
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/deletes/requirements.txt
@@ -0,0 +1 @@
+google-cloud-bigtable==2.35.0
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/__init__.py b/packages/google-cloud-bigtable/samples/snippets/filters/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets.py b/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets.py
new file mode 100644
index 000000000000..f2a1a0fd0a06
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets.py
@@ -0,0 +1,358 @@
+#!/usr/bin/env python
+
+# Copyright 2020, 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.
+
+
+# [START bigtable_filters_limit_row_sample]
+def filter_limit_row_sample(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.RowSampleFilter(0.75))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_row_sample]
+# [START bigtable_filters_limit_row_regex]
+def filter_limit_row_regex(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.RowKeyRegexFilter(".*#20190501$".encode("utf-8"))
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_row_regex]
+# [START bigtable_filters_limit_cells_per_col]
+def filter_limit_cells_per_col(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.CellsColumnLimitFilter(2))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_cells_per_col]
+# [START bigtable_filters_limit_cells_per_row]
+def filter_limit_cells_per_row(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.CellsRowLimitFilter(2))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_cells_per_row]
+# [START bigtable_filters_limit_cells_per_row_offset]
+def filter_limit_cells_per_row_offset(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.CellsRowOffsetFilter(2))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_cells_per_row_offset]
+# [START bigtable_filters_limit_col_family_regex]
+def filter_limit_col_family_regex(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.FamilyNameRegexFilter("stats_.*$".encode("utf-8"))
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_col_family_regex]
+# [START bigtable_filters_limit_col_qualifier_regex]
+def filter_limit_col_qualifier_regex(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.ColumnQualifierRegexFilter("connected_.*$".encode("utf-8"))
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_col_qualifier_regex]
+# [START bigtable_filters_limit_col_range]
+def filter_limit_col_range(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.ColumnRangeFilter(
+ "cell_plan", b"data_plan_01gb", b"data_plan_10gb", inclusive_end=False
+ )
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_col_range]
+# [START bigtable_filters_limit_value_range]
+def filter_limit_value_range(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.ValueRangeFilter(b"PQ2A.190405", b"PQ2A.190406")
+ )
+
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_value_range]
+# [START bigtable_filters_limit_value_regex]
+
+
+def filter_limit_value_regex(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.ValueRegexFilter("PQ2A.*$".encode("utf-8"))
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_value_regex]
+# [START bigtable_filters_limit_timestamp_range]
+def filter_limit_timestamp_range(project_id, instance_id, table_id):
+ import datetime
+
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ end = datetime.datetime(2019, 5, 1)
+
+ rows = table.read_rows(
+ filter_=row_filters.TimestampRangeFilter(row_filters.TimestampRange(end=end))
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_timestamp_range]
+# [START bigtable_filters_limit_block_all]
+def filter_limit_block_all(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.BlockAllFilter(True))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_block_all]
+# [START bigtable_filters_limit_pass_all]
+def filter_limit_pass_all(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.PassAllFilter(True))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_limit_pass_all]
+# [START bigtable_filters_modify_strip_value]
+def filter_modify_strip_value(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.StripValueTransformerFilter(True))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_modify_strip_value]
+# [START bigtable_filters_modify_apply_label]
+def filter_modify_apply_label(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.ApplyLabelFilter(label="labelled"))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_modify_apply_label]
+# [START bigtable_filters_composing_chain]
+def filter_composing_chain(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.RowFilterChain(
+ filters=[
+ row_filters.CellsColumnLimitFilter(1),
+ row_filters.FamilyNameRegexFilter("cell_plan"),
+ ]
+ )
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_composing_chain]
+# [START bigtable_filters_composing_interleave]
+def filter_composing_interleave(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.RowFilterUnion(
+ filters=[
+ row_filters.ValueRegexFilter("true"),
+ row_filters.ColumnQualifierRegexFilter("os_build"),
+ ]
+ )
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_composing_interleave]
+# [START bigtable_filters_composing_condition]
+def filter_composing_condition(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(
+ filter_=row_filters.ConditionalRowFilter(
+ base_filter=row_filters.RowFilterChain(
+ filters=[
+ row_filters.ColumnQualifierRegexFilter("data_plan_10gb"),
+ row_filters.ValueRegexFilter("true"),
+ ]
+ ),
+ true_filter=row_filters.ApplyLabelFilter(label="passed-filter"),
+ false_filter=row_filters.ApplyLabelFilter(label="filtered-out"),
+ )
+ )
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_filters_composing_condition]
+
+
+# [START bigtable_filters_print]
+def print_row(row):
+ print("Reading data for {}:".format(row.row_key.decode("utf-8")))
+ for cf, cols in sorted(row.cells.items()):
+ print("Column Family {}".format(cf))
+ for col, cells in sorted(cols.items()):
+ for cell in cells:
+ labels = (
+ " [{}]".format(",".join(cell.labels)) if len(cell.labels) else ""
+ )
+ print(
+ "\t{}: {} @{}{}".format(
+ col.decode("utf-8"),
+ cell.value.decode("utf-8"),
+ cell.timestamp,
+ labels,
+ )
+ )
+ print("")
+
+
+# [END bigtable_filters_print]
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets_async.py b/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets_async.py
new file mode 100644
index 000000000000..899d4c5c78e9
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets_async.py
@@ -0,0 +1,389 @@
+# Copyright 2024, 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.
+
+
+# [START bigtable_filters_limit_row_sample_asyncio]
+async def filter_limit_row_sample(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(row_filter=row_filters.RowSampleFilter(0.75))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_row_sample_asyncio]
+# [START bigtable_filters_limit_row_regex_asyncio]
+async def filter_limit_row_regex(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.RowKeyRegexFilter(".*#20190501$".encode("utf-8"))
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_row_regex_asyncio]
+# [START bigtable_filters_limit_cells_per_col_asyncio]
+async def filter_limit_cells_per_col(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(row_filter=row_filters.CellsColumnLimitFilter(2))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_cells_per_col_asyncio]
+# [START bigtable_filters_limit_cells_per_row_asyncio]
+async def filter_limit_cells_per_row(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(row_filter=row_filters.CellsRowLimitFilter(2))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_cells_per_row_asyncio]
+# [START bigtable_filters_limit_cells_per_row_offset_asyncio]
+async def filter_limit_cells_per_row_offset(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(row_filter=row_filters.CellsRowOffsetFilter(2))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_cells_per_row_offset_asyncio]
+# [START bigtable_filters_limit_col_family_regex_asyncio]
+async def filter_limit_col_family_regex(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.FamilyNameRegexFilter("stats_.*$".encode("utf-8"))
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_col_family_regex_asyncio]
+# [START bigtable_filters_limit_col_qualifier_regex_asyncio]
+async def filter_limit_col_qualifier_regex(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.ColumnQualifierRegexFilter(
+ "connected_.*$".encode("utf-8")
+ )
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_col_qualifier_regex_asyncio]
+# [START bigtable_filters_limit_col_range_asyncio]
+async def filter_limit_col_range(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.ColumnRangeFilter(
+ "cell_plan", b"data_plan_01gb", b"data_plan_10gb", inclusive_end=False
+ )
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_col_range_asyncio]
+# [START bigtable_filters_limit_value_range_asyncio]
+async def filter_limit_value_range(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.ValueRangeFilter(b"PQ2A.190405", b"PQ2A.190406")
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_value_range_asyncio]
+# [START bigtable_filters_limit_value_regex_asyncio]
+
+
+async def filter_limit_value_regex(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.ValueRegexFilter("PQ2A.*$".encode("utf-8"))
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_value_regex_asyncio]
+# [START bigtable_filters_limit_timestamp_range_asyncio]
+async def filter_limit_timestamp_range(project_id, instance_id, table_id):
+ import datetime
+
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ end = datetime.datetime(2019, 5, 1)
+
+ query = ReadRowsQuery(row_filter=row_filters.TimestampRangeFilter(end=end))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_timestamp_range_asyncio]
+# [START bigtable_filters_limit_block_all_asyncio]
+async def filter_limit_block_all(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(row_filter=row_filters.BlockAllFilter(True))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_block_all_asyncio]
+# [START bigtable_filters_limit_pass_all_asyncio]
+async def filter_limit_pass_all(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(row_filter=row_filters.PassAllFilter(True))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_limit_pass_all_asyncio]
+# [START bigtable_filters_modify_strip_value_asyncio]
+async def filter_modify_strip_value(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(row_filter=row_filters.StripValueTransformerFilter(True))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_modify_strip_value_asyncio]
+# [START bigtable_filters_modify_apply_label_asyncio]
+async def filter_modify_apply_label(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(row_filter=row_filters.ApplyLabelFilter(label="labelled"))
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_modify_apply_label_asyncio]
+# [START bigtable_filters_composing_chain_asyncio]
+async def filter_composing_chain(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.RowFilterChain(
+ filters=[
+ row_filters.CellsColumnLimitFilter(1),
+ row_filters.FamilyNameRegexFilter("cell_plan"),
+ ]
+ )
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_composing_chain_asyncio]
+# [START bigtable_filters_composing_interleave_asyncio]
+async def filter_composing_interleave(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.RowFilterUnion(
+ filters=[
+ row_filters.ValueRegexFilter("true"),
+ row_filters.ColumnQualifierRegexFilter("os_build"),
+ ]
+ )
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_composing_interleave_asyncio]
+# [START bigtable_filters_composing_condition_asyncio]
+async def filter_composing_condition(project_id, instance_id, table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ ReadRowsQuery,
+ row_filters,
+ )
+
+ query = ReadRowsQuery(
+ row_filter=row_filters.ConditionalRowFilter(
+ predicate_filter=row_filters.RowFilterChain(
+ filters=[
+ row_filters.ColumnQualifierRegexFilter("data_plan_10gb"),
+ row_filters.ValueRegexFilter("true"),
+ ]
+ ),
+ true_filter=row_filters.ApplyLabelFilter(label="passed-filter"),
+ false_filter=row_filters.ApplyLabelFilter(label="filtered-out"),
+ )
+ )
+
+ async with BigtableDataClientAsync(project=project_id) as client:
+ async with client.get_table(instance_id, table_id) as table:
+ for row in await table.read_rows(query):
+ print_row(row)
+
+
+# [END bigtable_filters_composing_condition_asyncio]
+
+
+def print_row(row):
+ from google.cloud._helpers import _datetime_from_microseconds
+
+ print("Reading data for {}:".format(row.row_key.decode("utf-8")))
+ last_family = None
+ for cell in row.cells:
+ if last_family != cell.family:
+ print("Column Family {}".format(cell.family))
+ last_family = cell.family
+
+ labels = " [{}]".format(",".join(cell.labels)) if len(cell.labels) else ""
+ print(
+ "\t{}: {} @{}{}".format(
+ cell.qualifier.decode("utf-8"),
+ cell.value.decode("utf-8"),
+ _datetime_from_microseconds(cell.timestamp_micros),
+ labels,
+ )
+ )
+ print("")
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets_async_test.py b/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets_async_test.py
new file mode 100644
index 000000000000..3c961a27b752
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/filters/filter_snippets_async_test.py
@@ -0,0 +1,450 @@
+# Copyright 2020, 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.
+
+
+import datetime
+import inspect
+import os
+import uuid
+from typing import AsyncGenerator
+
+import pytest
+import pytest_asyncio
+from google.cloud._helpers import (
+ _microseconds_from_datetime,
+)
+
+from ...utils import create_table_cm
+from . import filter_snippets_async
+from .snapshots.snap_filters_test import snapshots
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"mobile-time-series-filters-async-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture(scope="module")
+def event_loop():
+ import asyncio
+
+ loop = asyncio.get_event_loop_policy().new_event_loop()
+ yield loop
+ loop.close()
+
+
+@pytest_asyncio.fixture(scope="module", autouse=True)
+async def table_id() -> AsyncGenerator[str, None]:
+ with create_table_cm(
+ PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None, "cell_plan": None}
+ ):
+ await _populate_table(TABLE_ID)
+ yield TABLE_ID
+
+
+async def _populate_table(table_id):
+ from google.cloud.bigtable.data import (
+ BigtableDataClientAsync,
+ RowMutationEntry,
+ SetCell,
+ )
+
+ timestamp = datetime.datetime(2019, 5, 1)
+ timestamp_minus_hr = timestamp - datetime.timedelta(hours=1)
+
+ async with BigtableDataClientAsync(project=PROJECT) as client:
+ async with client.get_table(BIGTABLE_INSTANCE, table_id) as table:
+ async with table.mutations_batcher() as batcher:
+ await batcher.append(
+ RowMutationEntry(
+ "phone#4c410523#20190501",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190405.003",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_01gb",
+ "true",
+ _microseconds_from_datetime(timestamp_minus_hr),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_01gb",
+ "false",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_05gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+ await batcher.append(
+ RowMutationEntry(
+ "phone#4c410523#20190502",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190405.004",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_05gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+ await batcher.append(
+ RowMutationEntry(
+ "phone#4c410523#20190505",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 0,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190406.000",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_05gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+ await batcher.append(
+ RowMutationEntry(
+ "phone#5c10102#20190501",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190401.002",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_10gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+ await batcher.append(
+ RowMutationEntry(
+ "phone#5c10102#20190502",
+ [
+ SetCell(
+ "stats_summary",
+ "connected_cell",
+ 1,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "connected_wifi",
+ 0,
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "stats_summary",
+ "os_build",
+ "PQ2A.190406.000",
+ _microseconds_from_datetime(timestamp),
+ ),
+ SetCell(
+ "cell_plan",
+ "data_plan_10gb",
+ "true",
+ _microseconds_from_datetime(timestamp),
+ ),
+ ],
+ )
+ )
+
+
+def _datetime_to_micros(value: datetime.datetime) -> int:
+ """Uses the same conversion rules as the old client in"""
+ import calendar
+ import datetime as dt
+
+ if not value.tzinfo:
+ value = value.replace(tzinfo=datetime.timezone.utc)
+ # Regardless of what timezone is on the value, convert it to UTC.
+ value = value.astimezone(datetime.timezone.utc)
+ # Convert the datetime to a microsecond timestamp.
+ return int(calendar.timegm(value.timetuple()) * 1e6) + value.microsecond
+ return int(dt.timestamp() * 1000 * 1000)
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_row_sample(capsys, table_id):
+ await filter_snippets_async.filter_limit_row_sample(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ assert "Reading data for" in out
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_row_regex(capsys, table_id):
+ await filter_snippets_async.filter_limit_row_regex(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_cells_per_col(capsys, table_id):
+ await filter_snippets_async.filter_limit_cells_per_col(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_cells_per_row(capsys, table_id):
+ await filter_snippets_async.filter_limit_cells_per_row(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_cells_per_row_offset(capsys, table_id):
+ await filter_snippets_async.filter_limit_cells_per_row_offset(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_col_family_regex(capsys, table_id):
+ await filter_snippets_async.filter_limit_col_family_regex(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_col_qualifier_regex(capsys, table_id):
+ await filter_snippets_async.filter_limit_col_qualifier_regex(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_col_range(capsys, table_id):
+ await filter_snippets_async.filter_limit_col_range(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_value_range(capsys, table_id):
+ await filter_snippets_async.filter_limit_value_range(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_value_regex(capsys, table_id):
+ await filter_snippets_async.filter_limit_value_regex(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_timestamp_range(capsys, table_id):
+ await filter_snippets_async.filter_limit_timestamp_range(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_block_all(capsys, table_id):
+ await filter_snippets_async.filter_limit_block_all(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_limit_pass_all(capsys, table_id):
+ await filter_snippets_async.filter_limit_pass_all(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_modify_strip_value(capsys, table_id):
+ await filter_snippets_async.filter_modify_strip_value(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_modify_apply_label(capsys, table_id):
+ await filter_snippets_async.filter_modify_apply_label(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_composing_chain(capsys, table_id):
+ await filter_snippets_async.filter_composing_chain(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_composing_interleave(capsys, table_id):
+ await filter_snippets_async.filter_composing_interleave(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+@pytest.mark.asyncio
+async def test_filter_composing_condition(capsys, table_id):
+ await filter_snippets_async.filter_composing_condition(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/filters_test.py b/packages/google-cloud-bigtable/samples/snippets/filters/filters_test.py
new file mode 100644
index 000000000000..c5d780c90e80
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/filters/filters_test.py
@@ -0,0 +1,237 @@
+# Copyright 2020, 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.
+
+
+import datetime
+import inspect
+import os
+import time
+import uuid
+
+import pytest
+
+from ...utils import create_table_cm
+from . import filter_snippets
+from .snapshots.snap_filters_test import snapshots
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"mobile-time-series-filters-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture(scope="module", autouse=True)
+def table_id():
+ from google.cloud.bigtable.row_set import RowSet
+
+ table_id = TABLE_ID
+ with create_table_cm(
+ PROJECT, BIGTABLE_INSTANCE, table_id, {"stats_summary": None, "cell_plan": None}
+ ) as table:
+ timestamp = datetime.datetime(2019, 5, 1)
+ timestamp_minus_hr = datetime.datetime(2019, 5, 1) - datetime.timedelta(hours=1)
+
+ row_keys = [
+ "phone#4c410523#20190501",
+ "phone#4c410523#20190502",
+ "phone#4c410523#20190505",
+ "phone#5c10102#20190501",
+ "phone#5c10102#20190502",
+ ]
+
+ rows = [table.direct_row(row_key) for row_key in row_keys]
+
+ rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
+ rows[0].set_cell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr)
+ rows[0].set_cell("cell_plan", "data_plan_01gb", "false", timestamp)
+ rows[0].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
+ rows[1].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
+ rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[2].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
+ rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
+ rows[3].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
+ rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
+ rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[4].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
+
+ table.mutate_rows(rows)
+
+ # Ensure mutations have propagated.
+ row_set = RowSet()
+
+ for row_key in row_keys:
+ row_set.add_row_key(row_key)
+
+ fetched = list(table.read_rows(row_set=row_set))
+
+ while len(fetched) < len(rows):
+ time.sleep(5)
+ fetched = list(table.read_rows(row_set=row_set))
+
+ yield table_id
+
+
+def test_filter_limit_row_sample(capsys, table_id):
+ filter_snippets.filter_limit_row_sample(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ assert "Reading data for" in out
+
+
+def test_filter_limit_row_regex(capsys, table_id):
+ filter_snippets.filter_limit_row_regex(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_cells_per_col(capsys, table_id):
+ filter_snippets.filter_limit_cells_per_col(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_cells_per_row(capsys, table_id):
+ filter_snippets.filter_limit_cells_per_row(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_cells_per_row_offset(capsys, table_id):
+ filter_snippets.filter_limit_cells_per_row_offset(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_col_family_regex(capsys, table_id):
+ filter_snippets.filter_limit_col_family_regex(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_col_qualifier_regex(capsys, table_id):
+ filter_snippets.filter_limit_col_qualifier_regex(
+ PROJECT, BIGTABLE_INSTANCE, table_id
+ )
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_col_range(capsys, table_id):
+ filter_snippets.filter_limit_col_range(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_value_range(capsys, table_id):
+ filter_snippets.filter_limit_value_range(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_value_regex(capsys, table_id):
+ filter_snippets.filter_limit_value_regex(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_timestamp_range(capsys, table_id):
+ filter_snippets.filter_limit_timestamp_range(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_block_all(capsys, table_id):
+ filter_snippets.filter_limit_block_all(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_limit_pass_all(capsys, table_id):
+ filter_snippets.filter_limit_pass_all(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_modify_strip_value(capsys, table_id):
+ filter_snippets.filter_modify_strip_value(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_modify_apply_label(capsys, table_id):
+ filter_snippets.filter_modify_apply_label(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_composing_chain(capsys, table_id):
+ filter_snippets.filter_composing_chain(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_composing_interleave(capsys, table_id):
+ filter_snippets.filter_composing_interleave(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_filter_composing_condition(capsys, table_id):
+ filter_snippets.filter_composing_condition(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/noxfile.py b/packages/google-cloud-bigtable/samples/snippets/filters/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/filters/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/requirements-test.txt b/packages/google-cloud-bigtable/samples/snippets/filters/requirements-test.txt
new file mode 100644
index 000000000000..ee4ba018603b
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/filters/requirements-test.txt
@@ -0,0 +1,2 @@
+pytest
+pytest-asyncio
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/requirements.txt b/packages/google-cloud-bigtable/samples/snippets/filters/requirements.txt
new file mode 100644
index 000000000000..730d25dec63f
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/filters/requirements.txt
@@ -0,0 +1 @@
+google-cloud-bigtable==2.35.0
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/snapshots/__init__.py b/packages/google-cloud-bigtable/samples/snippets/filters/snapshots/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/snippets/filters/snapshots/snap_filters_test.py b/packages/google-cloud-bigtable/samples/snippets/filters/snapshots/snap_filters_test.py
new file mode 100644
index 000000000000..0547ddddd858
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/filters/snapshots/snap_filters_test.py
@@ -0,0 +1,503 @@
+# -*- coding: utf-8 -*-
+# this was previously implemented using the `snapshottest` package (https://goo.gl/zC4yUc),
+# which is not compatible with Python 3.12. So we moved to a standard dictionary storing
+# expected outputs for each test
+from __future__ import unicode_literals
+
+snapshots = {}
+
+snapshots["test_filter_limit_row_regex"] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: false @2019-05-01 00:00:00+00:00
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_limit_cells_per_col"
+] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: false @2019-05-01 00:00:00+00:00
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_limit_cells_per_row"
+] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: false @2019-05-01 00:00:00+00:00
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_limit_cells_per_row_offset"
+] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family stats_summary
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family stats_summary
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family stats_summary
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_limit_col_family_regex"
+] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_limit_col_qualifier_regex"
+] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots["test_filter_limit_col_range"] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: false @2019-05-01 00:00:00+00:00
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_limit_value_range"
+] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_limit_value_regex"
+] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family stats_summary
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family stats_summary
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family stats_summary
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_limit_timestamp_range"
+] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00
+
+"""
+
+snapshots["test_filter_limit_block_all"] = ""
+
+snapshots["test_filter_limit_pass_all"] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: false @2019-05-01 00:00:00+00:00
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_modify_strip_value"
+] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: @2019-05-01 00:00:00+00:00
+\tdata_plan_01gb: @2019-04-30 23:00:00+00:00
+\tdata_plan_05gb: @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: @2019-05-01 00:00:00+00:00
+\tconnected_wifi: @2019-05-01 00:00:00+00:00
+\tos_build: @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: @2019-05-01 00:00:00+00:00
+\tconnected_wifi: @2019-05-01 00:00:00+00:00
+\tos_build: @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: @2019-05-01 00:00:00+00:00
+\tconnected_wifi: @2019-05-01 00:00:00+00:00
+\tos_build: @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: @2019-05-01 00:00:00+00:00
+\tconnected_wifi: @2019-05-01 00:00:00+00:00
+\tos_build: @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family cell_plan
+\tdata_plan_10gb: @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tconnected_cell: @2019-05-01 00:00:00+00:00
+\tconnected_wifi: @2019-05-01 00:00:00+00:00
+\tos_build: @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_modify_apply_label"
+] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: false @2019-05-01 00:00:00+00:00 [labelled]
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00 [labelled]
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00 [labelled]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [labelled]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [labelled]
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00 [labelled]
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00 [labelled]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [labelled]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [labelled]
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00 [labelled]
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00 [labelled]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00 [labelled]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [labelled]
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00 [labelled]
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00 [labelled]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [labelled]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [labelled]
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00 [labelled]
+
+Reading data for phone#5c10102#20190502:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00 [labelled]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [labelled]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00 [labelled]
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00 [labelled]
+
+"""
+
+snapshots["test_filter_composing_chain"] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: false @2019-05-01 00:00:00+00:00
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_composing_interleave"
+] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00
+Column Family stats_summary
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots[
+ "test_filter_composing_condition"
+] = """Reading data for phone#4c410523#20190501:
+Column Family cell_plan
+\tdata_plan_01gb: false @2019-05-01 00:00:00+00:00 [filtered-out]
+\tdata_plan_01gb: true @2019-04-30 23:00:00+00:00 [filtered-out]
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00 [filtered-out]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [filtered-out]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [filtered-out]
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00 [filtered-out]
+
+Reading data for phone#4c410523#20190502:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00 [filtered-out]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [filtered-out]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [filtered-out]
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00 [filtered-out]
+
+Reading data for phone#4c410523#20190505:
+Column Family cell_plan
+\tdata_plan_05gb: true @2019-05-01 00:00:00+00:00 [filtered-out]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00 [filtered-out]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [filtered-out]
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00 [filtered-out]
+
+Reading data for phone#5c10102#20190501:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00 [passed-filter]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [passed-filter]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [passed-filter]
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00 [passed-filter]
+
+Reading data for phone#5c10102#20190502:
+Column Family cell_plan
+\tdata_plan_10gb: true @2019-05-01 00:00:00+00:00 [passed-filter]
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00 [passed-filter]
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00 [passed-filter]
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00 [passed-filter]
+
+"""
diff --git a/packages/google-cloud-bigtable/samples/snippets/reads/__init__.py b/packages/google-cloud-bigtable/samples/snippets/reads/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/snippets/reads/noxfile.py b/packages/google-cloud-bigtable/samples/snippets/reads/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/reads/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/snippets/reads/read_snippets.py b/packages/google-cloud-bigtable/samples/snippets/reads/read_snippets.py
new file mode 100644
index 000000000000..7bdf01c7c890
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/reads/read_snippets.py
@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+
+# Copyright 2020, 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.
+
+# [START bigtable_reads_row]
+def read_row(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ row_key = "phone#4c410523#20190501"
+
+ row = table.read_row(row_key)
+ print_row(row)
+
+
+# [END bigtable_reads_row]
+
+
+# [START bigtable_reads_row_partial]
+def read_row_partial(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ row_key = "phone#4c410523#20190501"
+ col_filter = row_filters.ColumnQualifierRegexFilter(b"os_build")
+
+ row = table.read_row(row_key, filter_=col_filter)
+ print_row(row)
+
+
+# [END bigtable_reads_row_partial]
+# [START bigtable_reads_rows]
+def read_rows(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable.row_set import RowSet
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ row_set = RowSet()
+ row_set.add_row_key(b"phone#4c410523#20190501")
+ row_set.add_row_key(b"phone#4c410523#20190502")
+
+ rows = table.read_rows(row_set=row_set)
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_reads_rows]
+# [START bigtable_reads_row_range]
+def read_row_range(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable.row_set import RowSet
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ row_set = RowSet()
+ row_set.add_row_range_from_keys(
+ start_key=b"phone#4c410523#20190501", end_key=b"phone#4c410523#201906201"
+ )
+
+ rows = table.read_rows(row_set=row_set)
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_reads_row_range]
+# [START bigtable_reads_row_ranges]
+def read_row_ranges(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable.row_set import RowSet
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ row_set = RowSet()
+ row_set.add_row_range_from_keys(
+ start_key=b"phone#4c410523#20190501", end_key=b"phone#4c410523#201906201"
+ )
+ row_set.add_row_range_from_keys(
+ start_key=b"phone#5c10102#20190501", end_key=b"phone#5c10102#201906201"
+ )
+
+ rows = table.read_rows(row_set=row_set)
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_reads_row_ranges]
+# [START bigtable_reads_prefix]
+def read_prefix(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable.row_set import RowSet
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+ prefix = "phone#"
+ end_key = prefix[:-1] + chr(ord(prefix[-1]) + 1)
+
+ row_set = RowSet()
+ row_set.add_row_range_from_keys(prefix.encode("utf-8"), end_key.encode("utf-8"))
+
+ rows = table.read_rows(row_set=row_set)
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_reads_prefix]
+# [START bigtable_reads_filter]
+def read_filter(project_id, instance_id, table_id):
+ from google.cloud import bigtable
+ from google.cloud.bigtable import row_filters
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ rows = table.read_rows(filter_=row_filters.ValueRegexFilter(b"PQ2A.*$"))
+ for row in rows:
+ print_row(row)
+
+
+# [END bigtable_reads_filter]
+
+
+# [START bigtable_reads_print]
+def print_row(row):
+ print("Reading data for {}:".format(row.row_key.decode("utf-8")))
+ for cf, cols in sorted(row.cells.items()):
+ print("Column Family {}".format(cf))
+ for col, cells in sorted(cols.items()):
+ for cell in cells:
+ labels = (
+ " [{}]".format(",".join(cell.labels)) if len(cell.labels) else ""
+ )
+ print(
+ "\t{}: {} @{}{}".format(
+ col.decode("utf-8"),
+ cell.value.decode("utf-8"),
+ cell.timestamp,
+ labels,
+ )
+ )
+ print("")
+
+
+# [END bigtable_reads_print]
diff --git a/packages/google-cloud-bigtable/samples/snippets/reads/reads_test.py b/packages/google-cloud-bigtable/samples/snippets/reads/reads_test.py
new file mode 100644
index 000000000000..251141954955
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/reads/reads_test.py
@@ -0,0 +1,118 @@
+# Copyright 2020, 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.
+
+import datetime
+import inspect
+import os
+import uuid
+
+import pytest
+
+from ...utils import create_table_cm
+from . import read_snippets
+from .snapshots.snap_reads_test import snapshots
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"mobile-time-series-reads-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture(scope="module", autouse=True)
+def table_id():
+ with create_table_cm(
+ PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None}
+ ) as table:
+ timestamp = datetime.datetime(2019, 5, 1)
+ rows = [
+ table.direct_row("phone#4c410523#20190501"),
+ table.direct_row("phone#4c410523#20190502"),
+ table.direct_row("phone#4c410523#20190505"),
+ table.direct_row("phone#5c10102#20190501"),
+ table.direct_row("phone#5c10102#20190502"),
+ ]
+
+ rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
+ rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
+ rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
+ rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+ rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
+ rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
+ rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
+ rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
+ rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
+
+ table.mutate_rows(rows)
+
+ yield TABLE_ID
+
+
+def test_read_row(capsys, table_id):
+ read_snippets.read_row(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_read_row_partial(capsys, table_id):
+ read_snippets.read_row_partial(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_read_rows(capsys, table_id):
+ read_snippets.read_rows(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_read_row_range(capsys, table_id):
+ read_snippets.read_row_range(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_read_row_ranges(capsys, table_id):
+ read_snippets.read_row_ranges(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_read_prefix(capsys, table_id):
+ read_snippets.read_prefix(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
+
+
+def test_read_filter(capsys, table_id):
+ read_snippets.read_filter(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ out, _ = capsys.readouterr()
+ expected = snapshots[inspect.currentframe().f_code.co_name]
+ assert out == expected
diff --git a/packages/google-cloud-bigtable/samples/snippets/reads/requirements-test.txt b/packages/google-cloud-bigtable/samples/snippets/reads/requirements-test.txt
new file mode 100644
index 000000000000..e079f8a6038d
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/reads/requirements-test.txt
@@ -0,0 +1 @@
+pytest
diff --git a/packages/google-cloud-bigtable/samples/snippets/reads/requirements.txt b/packages/google-cloud-bigtable/samples/snippets/reads/requirements.txt
new file mode 100644
index 000000000000..730d25dec63f
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/reads/requirements.txt
@@ -0,0 +1 @@
+google-cloud-bigtable==2.35.0
diff --git a/packages/google-cloud-bigtable/samples/snippets/reads/snapshots/__init__.py b/packages/google-cloud-bigtable/samples/snippets/reads/snapshots/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/snippets/reads/snapshots/snap_reads_test.py b/packages/google-cloud-bigtable/samples/snippets/reads/snapshots/snap_reads_test.py
new file mode 100644
index 000000000000..c2449d123a38
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/reads/snapshots/snap_reads_test.py
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+# this was previously implemented using the `snapshottest` package (https://goo.gl/zC4yUc),
+# which is not compatible with Python 3.12. So we moved to a standard dictionary storing
+# expected outputs for each test
+from __future__ import unicode_literals
+
+snapshots = {}
+
+snapshots["test_read_row_partial"] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots["test_read_rows"] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots["test_read_row_range"] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots["test_read_row_ranges"] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots["test_read_prefix"] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x00 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots["test_read_filter"] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190502:
+Column Family stats_summary
+\tos_build: PQ2A.190405.004 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#4c410523#20190505:
+Column Family stats_summary
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190501:
+Column Family stats_summary
+\tos_build: PQ2A.190401.002 @2019-05-01 00:00:00+00:00
+
+Reading data for phone#5c10102#20190502:
+Column Family stats_summary
+\tos_build: PQ2A.190406.000 @2019-05-01 00:00:00+00:00
+
+"""
+
+snapshots["test_read_row"] = """Reading data for phone#4c410523#20190501:
+Column Family stats_summary
+\tconnected_cell: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tconnected_wifi: \x00\x00\x00\x00\x00\x00\x00\x01 @2019-05-01 00:00:00+00:00
+\tos_build: PQ2A.190405.003 @2019-05-01 00:00:00+00:00
+
+"""
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/__init__.py b/packages/google-cloud-bigtable/samples/snippets/writes/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/noxfile.py b/packages/google-cloud-bigtable/samples/snippets/writes/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/writes/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/requirements-test.txt b/packages/google-cloud-bigtable/samples/snippets/writes/requirements-test.txt
new file mode 100644
index 000000000000..5e15eb26f589
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/writes/requirements-test.txt
@@ -0,0 +1,2 @@
+backoff==2.2.1
+pytest
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/requirements.txt b/packages/google-cloud-bigtable/samples/snippets/writes/requirements.txt
new file mode 100644
index 000000000000..54c0c14a3c5b
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/writes/requirements.txt
@@ -0,0 +1 @@
+google-cloud-bigtable==2.35.0
\ No newline at end of file
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/write_batch.py b/packages/google-cloud-bigtable/samples/snippets/writes/write_batch.py
new file mode 100644
index 000000000000..a583bb7134e1
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/writes/write_batch.py
@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+
+# Copyright 2019, 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.
+# [START bigtable_writes_batch]
+from datetime import datetime, timezone
+
+from google.cloud import bigtable
+from google.cloud.bigtable.batcher import MutationsBatcher
+
+
+def write_batch(project_id, instance_id, table_id):
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ with MutationsBatcher(table=table) as batcher:
+ timestamp = datetime.now(timezone.utc)
+ column_family_id = "stats_summary"
+
+ rows = [
+ table.direct_row("tablet#a0b81f74#20190501"),
+ table.direct_row("tablet#a0b81f74#20190502"),
+ ]
+
+ rows[0].set_cell(column_family_id, "connected_wifi", 1, timestamp)
+ rows[0].set_cell(column_family_id, "os_build", "12155.0.0-rc1", timestamp)
+ rows[1].set_cell(column_family_id, "connected_wifi", 1, timestamp)
+ rows[1].set_cell(column_family_id, "os_build", "12145.0.0-rc6", timestamp)
+
+ batcher.mutate_rows(rows)
+
+ print("Successfully wrote 2 rows.")
+
+
+# [END bigtable_writes_batch]
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/write_conditionally.py b/packages/google-cloud-bigtable/samples/snippets/writes/write_conditionally.py
new file mode 100644
index 000000000000..b6f05fba77f4
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/writes/write_conditionally.py
@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+
+# Copyright 2019, 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.
+# [START bigtable_writes_conditional]
+from datetime import datetime, timezone
+
+from google.cloud import bigtable
+from google.cloud.bigtable import row_filters
+
+
+def write_conditional(project_id, instance_id, table_id):
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ timestamp = datetime.now(timezone.utc)
+ column_family_id = "stats_summary"
+
+ row_key = "phone#4c410523#20190501"
+
+ row_filter = row_filters.RowFilterChain(
+ filters=[
+ row_filters.FamilyNameRegexFilter(column_family_id),
+ row_filters.ColumnQualifierRegexFilter("os_build"),
+ row_filters.ValueRegexFilter("PQ2A\\..*"),
+ ]
+ )
+ row = table.conditional_row(row_key, filter_=row_filter)
+ row.set_cell(column_family_id, "os_name", "android", timestamp)
+ row.commit()
+
+ print("Successfully updated row's os_name.")
+
+
+# [END bigtable_writes_conditional]
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/write_increment.py b/packages/google-cloud-bigtable/samples/snippets/writes/write_increment.py
new file mode 100644
index 000000000000..ac8e2d16af34
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/writes/write_increment.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+# Copyright 2019, 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.
+# [START bigtable_writes_increment]
+from google.cloud import bigtable
+
+
+def write_increment(project_id, instance_id, table_id):
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ column_family_id = "stats_summary"
+
+ row_key = "phone#4c410523#20190501"
+ row = table.append_row(row_key)
+
+ # Decrement the connected_wifi value by 1.
+ row.increment_cell_value(column_family_id, "connected_wifi", -1)
+ row.commit()
+
+ print("Successfully updated row {}.".format(row_key))
+
+
+# [END bigtable_writes_increment]
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/write_simple.py b/packages/google-cloud-bigtable/samples/snippets/writes/write_simple.py
new file mode 100644
index 000000000000..fb7074bc526e
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/writes/write_simple.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+# Copyright 2019, 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.
+
+# [START bigtable_writes_simple]
+from datetime import datetime, timezone
+
+from google.cloud import bigtable
+
+
+def write_simple(project_id, instance_id, table_id):
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ timestamp = datetime.now(timezone.utc)
+ column_family_id = "stats_summary"
+
+ row_key = "phone#4c410523#20190501"
+
+ row = table.direct_row(row_key)
+ row.set_cell(column_family_id, "connected_cell", 1, timestamp)
+ row.set_cell(column_family_id, "connected_wifi", 1, timestamp)
+ row.set_cell(column_family_id, "os_build", "PQ2A.190405.003", timestamp)
+
+ row.commit()
+
+ print("Successfully wrote row {}.".format(row_key))
+
+
+# [END bigtable_writes_simple]
diff --git a/packages/google-cloud-bigtable/samples/snippets/writes/writes_test.py b/packages/google-cloud-bigtable/samples/snippets/writes/writes_test.py
new file mode 100644
index 000000000000..663122d3e783
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/snippets/writes/writes_test.py
@@ -0,0 +1,72 @@
+# Copyright 2018 Google Inc.
+#
+# 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.
+
+import os
+import uuid
+
+import backoff
+import pytest
+from google.api_core.exceptions import DeadlineExceeded
+
+from ...utils import create_table_cm
+from .write_batch import write_batch
+from .write_conditionally import write_conditional
+from .write_increment import write_increment
+from .write_simple import write_simple
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"mobile-time-series-writes-{str(uuid.uuid4())[:16]}"
+
+
+@pytest.fixture
+def table_id():
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, TABLE_ID, {"stats_summary": None}):
+ yield TABLE_ID
+
+
+def test_writes(capsys, table_id):
+ # `row.commit()` sometimes ends up with DeadlineExceeded, so now
+ # we put retries with a hard deadline.
+ @backoff.on_exception(backoff.expo, DeadlineExceeded, max_time=60)
+ def _write_simple():
+ write_simple(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ _write_simple()
+ out, _ = capsys.readouterr()
+ assert "Successfully wrote row" in out
+
+ @backoff.on_exception(backoff.expo, DeadlineExceeded, max_time=60)
+ def _write_increment():
+ write_increment(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ _write_increment()
+ out, _ = capsys.readouterr()
+ assert "Successfully updated row" in out
+
+ @backoff.on_exception(backoff.expo, DeadlineExceeded, max_time=60)
+ def _write_conditional():
+ write_conditional(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ _write_conditional()
+ out, _ = capsys.readouterr()
+ assert "Successfully updated row's os_name" in out
+
+ @backoff.on_exception(backoff.expo, DeadlineExceeded, max_time=60)
+ def _write_batch():
+ write_batch(PROJECT, BIGTABLE_INSTANCE, table_id)
+
+ _write_batch()
+ out, _ = capsys.readouterr()
+ assert "Successfully wrote 2 rows" in out
diff --git a/packages/google-cloud-bigtable/samples/tableadmin/README.md b/packages/google-cloud-bigtable/samples/tableadmin/README.md
new file mode 100644
index 000000000000..b2f6a13af55a
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/tableadmin/README.md
@@ -0,0 +1,52 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+
+## Python Samples for Cloud Bigtable
+
+This directory contains samples for Cloud Bigtable, which may be used as a refererence for how to use this product.
+Samples, quickstarts, and other documentation are available at cloud.google.com.
+
+
+### Table Admin
+
+Demonstrates how to connect to Cloud Bigtable and run some basic operations.
+
+
+
+
+
+To run this sample:
+
+1. If this is your first time working with GCP products, you will need to set up [the Cloud SDK][cloud_sdk] or utilize [Google Cloud Shell][gcloud_shell]. This sample may [require authetication][authentication] and you will need to [enable billing][enable_billing].
+
+1. Make a fork of this repo and clone the branch locally, then navigate to the sample directory you want to use.
+
+1. Install the dependencies needed to run the samples.
+
+ pip install -r requirements.txt
+
+1. Run the sample using
+
+ python tableadmin.py
+
+
+
+usage: tableadmin.py [-h] [run] [delete] [--table TABLE] project_id instance_id
Demonstrates how to connect to Cloud Bigtable and run some basic operations.
Prerequisites: - Create a Cloud Bigtable cluster.
https://cloud.google.com/bigtable/docs/creating-cluster - Set your Google
Application Default Credentials.
https://developers.google.com/identity/protocols/application-default-
credentials
positional arguments:
project_id Your Cloud Platform project ID.
instance_id ID of the Cloud Bigtable instance to connect to.
optional arguments:
-h, --help show this help message and exit
--table TABLE Table to create and destroy. (default: Hello-Bigtable)
+
+## Additional Information
+
+You can read the documentation for more details on API usage and use GitHub
+to browse the source and [report issues][issues].
+
+### Contributing
+View the [contributing guidelines][contrib_guide], the [Python style guide][py_style] for more information.
+
+[authentication]: https://cloud.google.com/docs/authentication/getting-started
+[enable_billing]:https://cloud.google.com/apis/docs/getting-started#enabling_billing
+[client_library_python]: https://googlecloudplatform.github.io/google-cloud-python/
+[issues]: https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+[contrib_guide]: https://github.com/googleapis/google-cloud-python/blob/main/CONTRIBUTING.rst
+[py_style]: http://google.github.io/styleguide/pyguide.html
+[cloud_sdk]: https://cloud.google.com/sdk/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
+[gcloud_shell]: https://cloud.google.com/shell/docs
diff --git a/packages/google-cloud-bigtable/samples/tableadmin/__init__.py b/packages/google-cloud-bigtable/samples/tableadmin/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/google-cloud-bigtable/samples/tableadmin/noxfile.py b/packages/google-cloud-bigtable/samples/tableadmin/noxfile.py
new file mode 100644
index 000000000000..c0e60097b353
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/tableadmin/noxfile.py
@@ -0,0 +1,292 @@
+# Copyright 2019 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.
+
+from __future__ import print_function
+
+import glob
+import os
+import sys
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+ # You can opt out from the test for specific Python versions.
+ "ignored_versions": [],
+ # Old samples are opted out of enforcing Python type hints
+ # All new samples should feature them
+ "enforce_type_hints": False,
+ # An envvar key for determining the project id to use. Change it
+ # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+ # build specific Cloud project. You can also use your own string
+ # to use your own Cloud project.
+ "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+ # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+ # If you need to use a specific version of pip,
+ # change pip_version_override to the string representation
+ # of the version number, for example, "20.2.4"
+ "pip_version_override": None,
+ # A dictionary you want to inject into your test. Don't put any
+ # secrets here. These values will override predefined values.
+ "envs": {},
+}
+
+
+try:
+ # Ensure we can import noxfile_config in the project's directory.
+ sys.path.append(".")
+ from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+ print("No user noxfile_config found: detail: {}".format(e))
+ TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+ """Returns a dict for pytest invocation."""
+ ret = {}
+
+ # Override the GCLOUD_PROJECT and the alias.
+ env_key = TEST_CONFIG["gcloud_project_env"]
+ # This should error out if not set.
+ ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+ # Apply user supplied envs.
+ ret.update(TEST_CONFIG["envs"])
+ return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+ "True",
+ "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+# E203: whitespace before ‘:’
+# E266: too many leading ‘#’ for block comment
+# E501: line too long
+# I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+ "--show-source",
+ "--builtin=gettext",
+ "--max-complexity=20",
+ "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+ "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+ "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+ if not TEST_CONFIG["enforce_type_hints"]:
+ session.install("flake8")
+ else:
+ session.install("flake8", "flake8-annotations")
+
+ args = FLAKE8_COMMON_ARGS + [
+ ".",
+ ]
+ session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+ """Run black. Format code to uniform standard."""
+ session.install(BLACK_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+ """
+ Run isort to sort imports. Then run black
+ to format code to uniform standard.
+ """
+ session.install(BLACK_VERSION, ISORT_VERSION)
+ python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+ # Use the --fss option to sort imports using strict alphabetical order.
+ # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+ session.run("isort", "--fss", *python_files)
+ session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+ session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+ # check for presence of tests
+ test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+ "**/test_*.py", recursive=True
+ )
+ test_list.extend(glob.glob("**/tests", recursive=True))
+
+ if len(test_list) == 0:
+ print("No tests found, skipping directory.")
+ return
+
+ if TEST_CONFIG["pip_version_override"]:
+ pip_version = TEST_CONFIG["pip_version_override"]
+ session.install(f"pip=={pip_version}")
+ """Runs py.test for a particular project."""
+ concurrent_args = []
+ if os.path.exists("requirements.txt"):
+ if os.path.exists("constraints.txt"):
+ session.install("-r", "requirements.txt", "-c", "constraints.txt")
+ else:
+ session.install("-r", "requirements.txt")
+ with open("requirements.txt") as rfile:
+ packages = rfile.read()
+
+ if os.path.exists("requirements-test.txt"):
+ if os.path.exists("constraints-test.txt"):
+ session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+ else:
+ session.install("-r", "requirements-test.txt")
+ with open("requirements-test.txt") as rtfile:
+ packages += rtfile.read()
+
+ if INSTALL_LIBRARY_FROM_SOURCE:
+ session.install("-e", _get_repo_root())
+
+ if post_install:
+ post_install(session)
+
+ if "pytest-parallel" in packages:
+ concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+ elif "pytest-xdist" in packages:
+ concurrent_args.extend(["-n", "auto"])
+
+ session.run(
+ "pytest",
+ *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+ # Pytest will return 5 when no tests are collected. This can happen
+ # on travis where slow and flaky tests are excluded.
+ # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+ success_codes=[0, 5],
+ env=get_pytest_env_vars(),
+ )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+ """Runs py.test for a sample using the specified version of Python."""
+ if session.python in TESTED_VERSIONS:
+ _session_tests(session)
+ else:
+ session.skip(
+ "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+ )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+ """Returns the root folder of the project."""
+ # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+ p = Path(os.getcwd())
+ for i in range(10):
+ if p is None:
+ break
+ if Path(p / ".git").exists():
+ return str(p)
+ # .git is not available in repos cloned via Cloud Build
+ # setup.py is always in the library's root, so use that instead
+ # https://github.com/googleapis/synthtool/issues/792
+ if Path(p / "setup.py").exists():
+ return str(p)
+ p = p.parent
+ raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+ """(Re-)generates the readme for a sample."""
+ session.install("jinja2", "pyyaml")
+ dir_ = os.path.dirname(path)
+
+ if os.path.exists(os.path.join(dir_, "requirements.txt")):
+ session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+ in_file = os.path.join(dir_, "README.rst.in")
+ session.run(
+ "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+ )
diff --git a/packages/google-cloud-bigtable/samples/tableadmin/requirements-test.txt b/packages/google-cloud-bigtable/samples/tableadmin/requirements-test.txt
new file mode 100644
index 000000000000..f01fd134c400
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/tableadmin/requirements-test.txt
@@ -0,0 +1,2 @@
+pytest
+google-cloud-testutils==1.7.0
diff --git a/packages/google-cloud-bigtable/samples/tableadmin/requirements.txt b/packages/google-cloud-bigtable/samples/tableadmin/requirements.txt
new file mode 100644
index 000000000000..730d25dec63f
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/tableadmin/requirements.txt
@@ -0,0 +1 @@
+google-cloud-bigtable==2.35.0
diff --git a/packages/google-cloud-bigtable/samples/tableadmin/tableadmin.py b/packages/google-cloud-bigtable/samples/tableadmin/tableadmin.py
new file mode 100644
index 000000000000..d62cfa3328b0
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/tableadmin/tableadmin.py
@@ -0,0 +1,266 @@
+#!/usr/bin/env python
+
+# Copyright 2018, 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.
+
+"""Demonstrates how to connect to Cloud Bigtable and run some basic operations.
+# http://www.apache.org/licenses/LICENSE-2.0
+Prerequisites:
+- Create a Cloud Bigtable cluster.
+ https://cloud.google.com/bigtable/docs/creating-cluster
+- Set your Google Application Default Credentials.
+ https://developers.google.com/identity/protocols/application-default-credentials
+
+Operations performed:
+- Create a Cloud Bigtable table.
+- List tables for a Cloud Bigtable instance.
+- Print metadata of the newly created table.
+- Create Column Families with different GC rules.
+ - GC Rules like: MaxAge, MaxVersions, Union, Intersection and Nested.
+- Delete a Bigtable table.
+"""
+
+import argparse
+import datetime
+
+from google.cloud import bigtable
+from google.cloud.bigtable import column_family
+
+from ..utils import create_table_cm
+
+
+def run_table_operations(project_id, instance_id, table_id):
+ """Create a Bigtable table and perform basic operations on it
+
+ :type project_id: str
+ :param project_id: Project id of the client.
+
+ :type instance_id: str
+ :param instance_id: Instance of the client.
+
+ :type table_id: str
+ :param table_id: Table id to create table.
+ """
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ with create_table_cm(project_id, instance_id, table_id, verbose=False) as table:
+ # [START bigtable_list_tables]
+ tables = instance.list_tables()
+ print("Listing tables in current project...")
+ if tables != []:
+ for tbl in tables:
+ print(tbl.table_id)
+ else:
+ print("No table exists in current project...")
+ # [END bigtable_list_tables]
+
+ # [START bigtable_create_family_gc_max_age]
+ print("Creating column family cf1 with with MaxAge GC Rule...")
+ # Create a column family with GC policy : maximum age
+ # where age = current time minus cell timestamp
+
+ # Define the GC rule to retain data with max age of 5 days
+ max_age_rule = column_family.MaxAgeGCRule(datetime.timedelta(days=5))
+
+ column_family1 = table.column_family("cf1", max_age_rule)
+ column_family1.create()
+ print("Created column family cf1 with MaxAge GC Rule.")
+ # [END bigtable_create_family_gc_max_age]
+
+ # [START bigtable_create_family_gc_max_versions]
+ print("Creating column family cf2 with max versions GC rule...")
+ # Create a column family with GC policy : most recent N versions
+ # where 1 = most recent version
+
+ # Define the GC policy to retain only the most recent 2 versions
+ max_versions_rule = column_family.MaxVersionsGCRule(2)
+
+ column_family2 = table.column_family("cf2", max_versions_rule)
+ column_family2.create()
+ print("Created column family cf2 with Max Versions GC Rule.")
+ # [END bigtable_create_family_gc_max_versions]
+
+ # [START bigtable_create_family_gc_union]
+ print("Creating column family cf3 with union GC rule...")
+ # Create a column family with GC policy to drop data that matches
+ # at least one condition.
+ # Define a GC rule to drop cells older than 5 days or not the
+ # most recent version
+ union_rule = column_family.GCRuleUnion(
+ [
+ column_family.MaxAgeGCRule(datetime.timedelta(days=5)),
+ column_family.MaxVersionsGCRule(2),
+ ]
+ )
+
+ column_family3 = table.column_family("cf3", union_rule)
+ column_family3.create()
+ print("Created column family cf3 with Union GC rule")
+ # [END bigtable_create_family_gc_union]
+
+ # [START bigtable_create_family_gc_intersection]
+ print("Creating column family cf4 with Intersection GC rule...")
+ # Create a column family with GC policy to drop data that matches
+ # all conditions
+ # GC rule: Drop cells older than 5 days AND older than the most
+ # recent 2 versions
+ intersection_rule = column_family.GCRuleIntersection(
+ [
+ column_family.MaxAgeGCRule(datetime.timedelta(days=5)),
+ column_family.MaxVersionsGCRule(2),
+ ]
+ )
+
+ column_family4 = table.column_family("cf4", intersection_rule)
+ column_family4.create()
+ print("Created column family cf4 with Intersection GC rule.")
+ # [END bigtable_create_family_gc_intersection]
+
+ # [START bigtable_create_family_gc_nested]
+ print("Creating column family cf5 with a Nested GC rule...")
+ # Create a column family with nested GC policies.
+ # Create a nested GC rule:
+ # Drop cells that are either older than the 10 recent versions
+ # OR
+ # Drop cells that are older than a month AND older than the
+ # 2 recent versions
+ rule1 = column_family.MaxVersionsGCRule(10)
+ rule2 = column_family.GCRuleIntersection(
+ [
+ column_family.MaxAgeGCRule(datetime.timedelta(days=30)),
+ column_family.MaxVersionsGCRule(2),
+ ]
+ )
+
+ nested_rule = column_family.GCRuleUnion([rule1, rule2])
+
+ column_family5 = table.column_family("cf5", nested_rule)
+ column_family5.create()
+ print("Created column family cf5 with a Nested GC rule.")
+ # [END bigtable_create_family_gc_nested]
+
+ # [START bigtable_list_column_families]
+ print("Printing Column Family and GC Rule for all column families...")
+ column_families = table.list_column_families()
+ for column_family_name, gc_rule in sorted(column_families.items()):
+ print("Column Family:", column_family_name)
+ print("GC Rule:")
+ print(gc_rule.to_pb())
+ # Sample output:
+ # Column Family: cf4
+ # GC Rule:
+ # gc_rule {
+ # intersection {
+ # rules {
+ # max_age {
+ # seconds: 432000
+ # }
+ # }
+ # rules {
+ # max_num_versions: 2
+ # }
+ # }
+ # }
+ # [END bigtable_list_column_families]
+
+ print("Print column family cf1 GC rule before update...")
+ print("Column Family: cf1")
+ print(column_family1.to_pb())
+
+ # [START bigtable_update_gc_rule]
+ print("Updating column family cf1 GC rule...")
+ # Update the column family cf1 to update the GC rule
+ column_family1 = table.column_family("cf1", column_family.MaxVersionsGCRule(1))
+ column_family1.update()
+ print("Updated column family cf1 GC rule\n")
+ # [END bigtable_update_gc_rule]
+
+ print("Print column family cf1 GC rule after update...")
+ print("Column Family: cf1")
+ print(column_family1.to_pb())
+
+ # [START bigtable_delete_family]
+ print("Delete a column family cf2...")
+ # Delete a column family
+ column_family2.delete()
+ print("Column family cf2 deleted successfully.")
+ # [END bigtable_delete_family]
+
+ print(
+ 'execute command "python tableadmin.py delete [project_id] \
+ [instance_id] --table [tableName]" to delete the table.'
+ )
+
+
+def delete_table(project_id, instance_id, table_id):
+ """Delete bigtable.
+
+ :type project_id: str
+ :param project_id: Project id of the client.
+
+ :type instance_id: str
+ :param instance_id: Instance of the client.
+
+ :type table_id: str
+ :param table_id: Table id to create table.
+ """
+
+ client = bigtable.Client(project=project_id, admin=True)
+ instance = client.instance(instance_id)
+ table = instance.table(table_id)
+
+ # [START bigtable_delete_table]
+ # Delete the entire table
+
+ print("Checking if table {} exists...".format(table_id))
+ if table.exists():
+ print("Table {} exists.".format(table_id))
+ print("Deleting {} table.".format(table_id))
+ table.delete()
+ print("Deleted {} table.".format(table_id))
+ else:
+ print("Table {} does not exists.".format(table_id))
+ # [END bigtable_delete_table]
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
+ )
+
+ parser.add_argument(
+ "command",
+ help="run or delete. \
+ Operation to perform on table.",
+ )
+ parser.add_argument(
+ "--table", help="Cloud Bigtable Table name.", default="Hello-Bigtable"
+ )
+
+ parser.add_argument("project_id", help="Your Cloud Platform project ID.")
+ parser.add_argument(
+ "instance_id", help="ID of the Cloud Bigtable instance to connect to."
+ )
+
+ args = parser.parse_args()
+
+ if args.command.lower() == "run":
+ run_table_operations(args.project_id, args.instance_id, args.table)
+ elif args.command.lower() == "delete":
+ delete_table(args.project_id, args.instance_id, args.table)
+ else:
+ print(
+ "Command should be either run or delete.\n Use argument -h,\
+ --help to show help and exit."
+ )
diff --git a/packages/google-cloud-bigtable/samples/tableadmin/tableadmin_test.py b/packages/google-cloud-bigtable/samples/tableadmin/tableadmin_test.py
new file mode 100755
index 000000000000..1c4cc41a1964
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/tableadmin/tableadmin_test.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+# Copyright 2018, 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.
+
+import os
+import uuid
+
+from google.api_core import exceptions
+from test_utils.retry import RetryErrors
+
+from ..utils import create_table_cm
+from .tableadmin import delete_table, run_table_operations
+
+PROJECT = os.environ["GOOGLE_CLOUD_PROJECT"]
+BIGTABLE_INSTANCE = os.environ["BIGTABLE_INSTANCE"]
+TABLE_ID = f"tableadmin-test-{str(uuid.uuid4())[:16]}"
+
+retry_429_503 = RetryErrors(exceptions.TooManyRequests, exceptions.ServiceUnavailable)
+
+
+def test_run_table_operations(capsys):
+ retry_429_503(run_table_operations)(PROJECT, BIGTABLE_INSTANCE, TABLE_ID)
+ out, _ = capsys.readouterr()
+
+ assert "Listing tables in current project." in out
+ assert "Creating column family cf1 with with MaxAge GC Rule" in out
+ assert "Created column family cf1 with MaxAge GC Rule." in out
+ assert "Created column family cf2 with Max Versions GC Rule." in out
+ assert "Created column family cf3 with Union GC rule" in out
+ assert "Created column family cf4 with Intersection GC rule." in out
+ assert "Created column family cf5 with a Nested GC rule." in out
+ assert "Printing Column Family and GC Rule for all column families." in out
+ assert "Updating column family cf1 GC rule..." in out
+ assert "Updated column family cf1 GC rule" in out
+ assert "Print column family cf1 GC rule after update..." in out
+ assert "Column Family: cf1" in out
+ assert "max_num_versions: 1" in out
+ assert "Delete a column family cf2..." in out
+ assert "Column family cf2 deleted successfully." in out
+
+
+def test_delete_table(capsys):
+ table_id = f"table-admin-to-delete-{str(uuid.uuid4())[:16]}"
+ with create_table_cm(PROJECT, BIGTABLE_INSTANCE, table_id, verbose=False):
+ delete_table(PROJECT, BIGTABLE_INSTANCE, table_id)
+ out, _ = capsys.readouterr()
+
+ assert "Table " + table_id + " exists." in out
+ assert "Deleting " + table_id + " table." in out
+ assert "Deleted " + table_id + " table." in out
diff --git a/packages/google-cloud-bigtable/samples/testdata/README.md b/packages/google-cloud-bigtable/samples/testdata/README.md
new file mode 100644
index 000000000000..57520179f2dc
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/testdata/README.md
@@ -0,0 +1,5 @@
+#### To generate singer_pb2.py and descriptors.pb file from singer.proto using `protoc`
+```shell
+cd samples
+protoc --proto_path=testdata/ --include_imports --descriptor_set_out=testdata/descriptors.pb --python_out=testdata/ testdata/singer.proto
+```
\ No newline at end of file
diff --git a/packages/google-cloud-bigtable/samples/testdata/descriptors.pb b/packages/google-cloud-bigtable/samples/testdata/descriptors.pb
new file mode 100644
index 000000000000..bddf04de3782
Binary files /dev/null and b/packages/google-cloud-bigtable/samples/testdata/descriptors.pb differ
diff --git a/packages/google-cloud-bigtable/samples/testdata/singer.proto b/packages/google-cloud-bigtable/samples/testdata/singer.proto
new file mode 100644
index 000000000000..d60e0dfb3b2a
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/testdata/singer.proto
@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package examples.bigtable.music;
+
+enum Genre {
+ POP = 0;
+ JAZZ = 1;
+ FOLK = 2;
+ ROCK = 3;
+}
+
+message Singer {
+ string name = 1;
+ Genre genre = 2;
+}
diff --git a/packages/google-cloud-bigtable/samples/testdata/singer_pb2.py b/packages/google-cloud-bigtable/samples/testdata/singer_pb2.py
new file mode 100644
index 000000000000..f5da249d4811
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/testdata/singer_pb2.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: singer.proto
+"""Generated protocol buffer code."""
+
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+ b'\n\x0csinger.proto\x12\x17\x65xamples.bigtable.music"E\n\x06Singer\x12\x0c\n\x04name\x18\x01 \x01(\t\x12-\n\x05genre\x18\x02 \x01(\x0e\x32\x1e.examples.bigtable.music.Genre*.\n\x05Genre\x12\x07\n\x03POP\x10\x00\x12\x08\n\x04JAZZ\x10\x01\x12\x08\n\x04\x46OLK\x10\x02\x12\x08\n\x04ROCK\x10\x03\x62\x06proto3'
+)
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "singer_pb2", globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+ DESCRIPTOR._options = None
+ _GENRE._serialized_start = 112
+ _GENRE._serialized_end = 158
+ _SINGER._serialized_start = 41
+ _SINGER._serialized_end = 110
+# @@protoc_insertion_point(module_scope)
diff --git a/packages/google-cloud-bigtable/samples/utils.py b/packages/google-cloud-bigtable/samples/utils.py
new file mode 100644
index 000000000000..d093d0427cbf
--- /dev/null
+++ b/packages/google-cloud-bigtable/samples/utils.py
@@ -0,0 +1,105 @@
+# Copyright 2024, 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.
+"""
+Provides helper logic used across samples
+"""
+
+from google.api_core import exceptions
+from google.api_core.retry import Retry, if_exception_type
+
+from google.cloud import bigtable
+from google.cloud.bigtable.column_family import ColumnFamily
+from google.cloud.bigtable_admin_v2.types import ColumnFamily as ColumnFamily_pb
+
+delete_retry = Retry(
+ if_exception_type(exceptions.TooManyRequests, exceptions.ServiceUnavailable)
+)
+
+
+class create_table_cm:
+ """
+ Create a new table using a context manager, to ensure that table.delete() is called to clean up
+ the table, even if an exception is thrown
+ """
+
+ def __init__(self, *args, verbose=True, **kwargs):
+ self._args = args
+ self._kwargs = kwargs
+ self._verbose = verbose
+
+ def __enter__(self):
+ self._table = create_table(*self._args, **self._kwargs)
+ if self._verbose:
+ print(f"created table: {self._table.table_id}")
+ return self._table
+
+ def __exit__(self, *args):
+ if self._table.exists():
+ if self._verbose:
+ print(f"deleting table: {self._table.table_id}")
+ delete_retry(self._table.delete())
+ else:
+ if self._verbose:
+ print(f"table {self._table.table_id} not found")
+
+
+def create_table(project, instance_id, table_id, column_families={}):
+ """
+ Creates a new table, and blocks until it reaches a ready state
+ """
+ client = bigtable.Client(project=project, admin=True)
+ instance = client.instance(instance_id)
+
+ table = instance.table(table_id)
+ if table.exists():
+ table.delete()
+
+ # convert column families to pb if needed
+ pb_families = {
+ id: ColumnFamily(id, table, rule).to_pb()
+ if not isinstance(rule, ColumnFamily_pb)
+ else rule
+ for (id, rule) in column_families.items()
+ }
+
+ # create table using gapic layer
+ instance._client.table_admin_client.create_table(
+ request={
+ "parent": instance.name,
+ "table_id": table_id,
+ "table": {"column_families": pb_families},
+ }
+ )
+
+ wait_for_table(table)
+
+ return table
+
+
+@Retry(
+ on_error=if_exception_type(
+ exceptions.PreconditionFailed,
+ exceptions.FailedPrecondition,
+ exceptions.NotFound,
+ ),
+ timeout=120,
+)
+def wait_for_table(table):
+ """
+ raises an exception if the table does not exist or is not ready to use
+
+ Because this method is wrapped with an api_core.Retry decorator, it will
+ retry with backoff if the table is not ready
+ """
+ if not table.exists():
+ raise exceptions.NotFound