spanner-adbc 0.8.0__py3-none-win_amd64.whl

spanner_adbc/__init__.py

@@ -0,0 +1,80 @@
+"""ADBC driver for Google Cloud Spanner.
+
+This package bundles the prebuilt Spanner ADBC driver shared library and exposes
+a thin Python wrapper around it. The heavy lifting lives in the Rust cdylib; this
+module just locates the bundled library and hands it to ``adbc_driver_manager``,
+which loads it over the ADBC C ABI.
+
+For a DBAPI 2.0 (PEP 249) connection with pandas/polars/Arrow helpers, use
+:func:`spanner_adbc.dbapi.connect` instead of the low-level
+:func:`connect` here.
+
+To reach the driver through the *generic* ``adbc_driver_manager`` instead — as
+``driver="spanner"``, or by URI scheme alone from ``uri="spanner:///..."`` —
+install an ADBC driver manifest once with ``python -m
+spanner_adbc.manifest install`` (see :mod:`spanner_adbc.manifest`).
+"""
+
+import functools
+import pathlib
+import typing
+
+import adbc_driver_manager
+
+from ._options import ConnectionOptions, DatabaseOptions, StatementOptions
+from ._version import __version__
+
+__all__ = [
+    "connect",
+    "ENTRYPOINT",
+    "DatabaseOptions",
+    "ConnectionOptions",
+    "StatementOptions",
+    "__version__",
+]
+
+#: C entrypoint exported by the shared library (see src/ffi.rs).
+ENTRYPOINT = "AdbcSpannerInit"
+
+
+def connect(
+    db_kwargs: typing.Optional[typing.Mapping[str, str]] = None,
+) -> adbc_driver_manager.AdbcDatabase:
+    """Create a low-level ADBC database handle for Spanner.
+
+    Parameters
+    ----------
+    db_kwargs:
+        Database-level driver options, keyed by their raw option strings — best
+        written with the :class:`DatabaseOptions` constants, e.g.
+        ``{DatabaseOptions.URI.value: "spanner:///projects/<p>/instances/<i>/databases/<d>"}``
+        (see src/lib.rs / docs/options.md). The ``uri`` option requires the
+        ``spanner://`` scheme; a bare database path is rejected. Credentials, the
+        emulator, endpoint overrides, and every other setting are all passed here
+        as their raw keys — for example
+        ``{DatabaseOptions.URI.value: "...", DatabaseOptions.KEYFILE.value: "/path/key.json"}``
+        or ``{DatabaseOptions.URI.value: "...", DatabaseOptions.EMULATOR.value: "true"}``.
+
+    For a DBAPI 2.0 connection, prefer :func:`spanner_adbc.dbapi.connect`.
+    """
+    # ** unpacking accepts the dotted, non-identifier option keys; they land in
+    # AdbcDatabase's **kwargs and are forwarded as ADBC options.
+    options = dict(db_kwargs) if db_kwargs else {}
+    return adbc_driver_manager.AdbcDatabase(
+        driver=_driver_path(), entrypoint=ENTRYPOINT, **options
+    )
+
+
+@functools.cache
+def _driver_path() -> str:
+    """Absolute path to the shared library bundled in this wheel."""
+    here = pathlib.Path(__file__).resolve().parent
+    for name in ("libspanner_adbc.so", "libspanner_adbc.dylib", "spanner_adbc.dll"):
+        candidate = here / name
+        if candidate.is_file():
+            return str(candidate)
+    raise RuntimeError(
+        "spanner_adbc: no bundled Spanner driver library found next to "
+        f"{here}. This usually means a source/sdist install without a matching "
+        "platform wheel; install a prebuilt wheel for your platform instead."
+    )

spanner_adbc/_options.py

@@ -0,0 +1,176 @@
+"""Typed option-key constants for the Spanner ADBC driver.
+
+These enums mirror the style of the BigQuery ADBC driver's ``DatabaseOptions`` /
+``StatementOptions``: each member's ``.value`` is the raw option-key string the
+driver understands. Every driver setting is passed as one of these keys — through
+``db_kwargs=`` / ``conn_kwargs=`` on :func:`spanner_adbc.dbapi.connect`, or
+``adbc_stmt_kwargs=`` on ``conn.cursor(...)`` — and these enums make that
+discoverable and typo-safe.
+
+Example::
+
+    import spanner_adbc.dbapi as spanner
+    from spanner_adbc import ConnectionOptions, DatabaseOptions, StatementOptions
+
+    with spanner.connect(
+        db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/p/instances/i/databases/d"},
+        conn_kwargs={ConnectionOptions.READ_STALENESS.value: "max:10s"},
+    ) as conn:
+        cur = conn.cursor(
+            adbc_stmt_kwargs={StatementOptions.ROWS_PER_BATCH.value: "1024"}
+        )
+
+Standard ADBC option keys (``adbc.*``) live in ``adbc_driver_manager``; a few that
+the driver honours are included here for convenience. The authoritative reference
+for every option, its type, default and behaviour is ``docs/options.md``.
+"""
+
+import enum
+
+__all__ = ["DatabaseOptions", "ConnectionOptions", "StatementOptions"]
+
+
+class DatabaseOptions(enum.Enum):
+    """Database-level options (set before connecting, via ``db_kwargs``)."""
+
+    #: **Standard ADBC.** A ``spanner://`` connection URI whose path is the fully-qualified
+    #: database path, ``spanner:///projects/<p>/instances/<i>/databases/<d>``. The scheme is
+    #: required; a bare path is rejected. Also settable as the ``uri`` kwarg on ``connect``.
+    URI = "uri"
+    #: Override the Spanner gRPC endpoint (e.g. an emulator ``host:port``).
+    ENDPOINT = "spanner.endpoint"
+    #: ``"true"`` to connect with anonymous credentials (emulator mode).
+    EMULATOR = "spanner.emulator"
+    #: Path to a service-account / credential JSON file.
+    KEYFILE = "spanner.auth.keyfile"
+    #: The same credential JSON passed inline as a string. Write-only: never
+    #: readable back via ``get_option``, and not accepted as a ``URI`` query
+    #: parameter (URIs get logged) — pass it here instead.
+    KEYFILE_JSON = "spanner.auth.keyfile_json"
+    #: A caller-supplied OAuth 2.0 bearer token, sent verbatim (no refresh).
+    #: Write-only: never readable back via ``get_option``, and not accepted as a
+    #: ``URI`` query parameter (URIs get logged) — pass it here instead.
+    ACCESS_TOKEN = "spanner.auth.access_token"
+    #: Service account to impersonate; setting it enables impersonation.
+    IMPERSONATE_TARGET_PRINCIPAL = "spanner.auth.impersonate.target_principal"
+    #: Optional impersonation delegation chain (comma-separated emails).
+    IMPERSONATE_DELEGATES = "spanner.auth.impersonate.delegates"
+    #: Optional OAuth scopes for the impersonated token (comma-separated).
+    IMPERSONATE_SCOPES = "spanner.auth.impersonate.scopes"
+    #: Optional impersonated-token lifetime, in seconds (default ``3600``).
+    IMPERSONATE_LIFETIME = "spanner.auth.impersonate.lifetime"
+    #: The GCP project charged for API quota (the ``x-goog-user-project`` header),
+    #: decoupled from the project owning the data. ``""`` unsets.
+    QUOTA_PROJECT = "spanner.auth.quota_project"
+
+
+class ConnectionOptions(enum.Enum):
+    """Connection-level options (set via ``conn_kwargs``)."""
+
+    #: Standard ADBC. ``"false"`` enters buffer-and-commit manual-transaction mode.
+    AUTOCOMMIT = "adbc.connection.autocommit"
+    #: Standard ADBC. ``"true"`` rejects all writes on the connection.
+    READONLY = "adbc.connection.readonly"
+    #: Standard ADBC. Isolation level for read/write transactions.
+    ISOLATION_LEVEL = "adbc.connection.transaction.isolation_level"
+    #: Read bound: one of ``exact:<duration>`` / ``max:<duration>`` / ``read:<rfc3339>`` /
+    #: ``min:<rfc3339>``.
+    READ_STALENESS = "spanner.read.staleness"
+    #: How ``TIMESTAMP`` maps to Arrow (``nanoseconds_error_on_overflow`` / ``microseconds``).
+    MAX_TIMESTAMP_PRECISION = "spanner.max_timestamp_precision"
+    #: Request priority (``low`` / ``medium`` / ``high``).
+    REQUEST_PRIORITY = "spanner.request.priority"
+    #: Request tag attached to every query/DML request.
+    REQUEST_TAG = "spanner.request.tag"
+    #: Transaction tag attached to every read/write transaction (connection-only).
+    TRANSACTION_TAG = "spanner.transaction.tag"
+    #: Directed-read replica selection for read-only queries.
+    DIRECTED_READ = "spanner.directed_read"
+    #: Query optimizer version.
+    QUERY_OPTIMIZER_VERSION = "spanner.query.optimizer_version"
+    #: Query optimizer statistics package.
+    QUERY_OPTIMIZER_STATISTICS_PACKAGE = "spanner.query.optimizer_statistics_package"
+    #: Maximum commit delay (``0..=500ms``) Spanner may add to batch commits.
+    MAX_COMMIT_DELAY = "spanner.commit.max_delay"
+    #: ``"true"`` requests commit statistics on read/write commits.
+    COMMIT_STATS = "spanner.commit_stats"
+    #: ``"true"`` excludes the transaction's writes from change-stream capture.
+    EXCLUDE_TXN_FROM_CHANGE_STREAMS = "spanner.transaction.exclude_from_change_streams"
+    #: Overall deadline (seconds) on a query's initial execution; ``0`` disables.
+    RPC_TIMEOUT_QUERY = "spanner.rpc.timeout_seconds.query"
+    #: Overall deadline (seconds) on each write operation; ``0`` disables.
+    RPC_TIMEOUT_UPDATE = "spanner.rpc.timeout_seconds.update"
+    #: Overall deadline (seconds) on each subsequent chunk fetch; ``0`` disables.
+    RPC_TIMEOUT_FETCH = "spanner.rpc.timeout_seconds.fetch"
+    #: Cap on retry attempts (first try + retries) for a retryable RPC.
+    RETRY_MAX_ATTEMPTS = "spanner.retry.max_attempts"
+    #: Cap (seconds) on total wall-clock time spent retrying a retryable RPC.
+    RETRY_MAX_ELAPSED_SECONDS = "spanner.retry.max_elapsed_seconds"
+    #: Initial delay (seconds) of the exponential backoff between retry attempts.
+    RETRY_BACKOFF_INITIAL_SECONDS = "spanner.retry.backoff.initial_seconds"
+    #: Ceiling (seconds) the growing retry backoff delay is truncated at.
+    RETRY_BACKOFF_MAX_SECONDS = "spanner.retry.backoff.max_seconds"
+    #: Per-attempt growth factor for the retry backoff delay.
+    RETRY_BACKOFF_MULTIPLIER = "spanner.retry.backoff.multiplier"
+
+
+class StatementOptions(enum.Enum):
+    """Statement-level options (set via ``conn.cursor(adbc_stmt_kwargs=...)``).
+
+    The options shared with :class:`ConnectionOptions` are per-statement overrides
+    of the value inherited from the connection.
+    """
+
+    #: Rows converted into each streamed Arrow ``RecordBatch`` (default ``8192``).
+    ROWS_PER_BATCH = "spanner.rows_per_batch"
+    #: ``"true"`` runs ``execute_partitions`` partitions on Data Boost.
+    DATA_BOOST = "spanner.data_boost"
+    #: Per-statement override of :attr:`ConnectionOptions.READ_STALENESS`.
+    READ_STALENESS = "spanner.read.staleness"
+    #: Per-statement override of :attr:`ConnectionOptions.MAX_TIMESTAMP_PRECISION`.
+    MAX_TIMESTAMP_PRECISION = "spanner.max_timestamp_precision"
+    #: Per-statement override of :attr:`ConnectionOptions.REQUEST_PRIORITY`.
+    REQUEST_PRIORITY = "spanner.request.priority"
+    #: Per-statement override of :attr:`ConnectionOptions.REQUEST_TAG`.
+    REQUEST_TAG = "spanner.request.tag"
+    #: Per-statement override of :attr:`ConnectionOptions.DIRECTED_READ`.
+    DIRECTED_READ = "spanner.directed_read"
+    #: Per-statement override of :attr:`ConnectionOptions.MAX_COMMIT_DELAY`.
+    MAX_COMMIT_DELAY = "spanner.commit.max_delay"
+    #: Per-statement override of :attr:`ConnectionOptions.COMMIT_STATS`.
+    COMMIT_STATS = "spanner.commit_stats"
+    #: Per-statement override of
+    #: :attr:`ConnectionOptions.EXCLUDE_TXN_FROM_CHANGE_STREAMS`.
+    EXCLUDE_TXN_FROM_CHANGE_STREAMS = "spanner.transaction.exclude_from_change_streams"
+    #: Per-statement override of :attr:`ConnectionOptions.QUERY_OPTIMIZER_VERSION`.
+    QUERY_OPTIMIZER_VERSION = "spanner.query.optimizer_version"
+    #: Per-statement override of :attr:`ConnectionOptions.QUERY_OPTIMIZER_STATISTICS_PACKAGE`.
+    QUERY_OPTIMIZER_STATISTICS_PACKAGE = "spanner.query.optimizer_statistics_package"
+    #: Per-statement override of :attr:`ConnectionOptions.RPC_TIMEOUT_QUERY`.
+    RPC_TIMEOUT_QUERY = "spanner.rpc.timeout_seconds.query"
+    #: Per-statement override of :attr:`ConnectionOptions.RPC_TIMEOUT_UPDATE`.
+    RPC_TIMEOUT_UPDATE = "spanner.rpc.timeout_seconds.update"
+    #: Per-statement override of :attr:`ConnectionOptions.RPC_TIMEOUT_FETCH`.
+    RPC_TIMEOUT_FETCH = "spanner.rpc.timeout_seconds.fetch"
+    #: Per-statement override of :attr:`ConnectionOptions.RETRY_MAX_ATTEMPTS`.
+    RETRY_MAX_ATTEMPTS = "spanner.retry.max_attempts"
+    #: Per-statement override of :attr:`ConnectionOptions.RETRY_MAX_ELAPSED_SECONDS`.
+    RETRY_MAX_ELAPSED_SECONDS = "spanner.retry.max_elapsed_seconds"
+    #: Per-statement override of :attr:`ConnectionOptions.RETRY_BACKOFF_INITIAL_SECONDS`.
+    RETRY_BACKOFF_INITIAL_SECONDS = "spanner.retry.backoff.initial_seconds"
+    #: Per-statement override of :attr:`ConnectionOptions.RETRY_BACKOFF_MAX_SECONDS`.
+    RETRY_BACKOFF_MAX_SECONDS = "spanner.retry.backoff.max_seconds"
+    #: Per-statement override of :attr:`ConnectionOptions.RETRY_BACKOFF_MULTIPLIER`.
+    RETRY_BACKOFF_MULTIPLIER = "spanner.retry.backoff.multiplier"
+    #: How bound Arrow columns pair with ``@name`` parameters (``"true"`` = by name).
+    BIND_BY_NAME = "adbc.statement.bind_by_name"
+    #: ``"true"`` routes an autocommit bulk ingest's chunks through Spanner's
+    #: non-atomic **BatchWrite** RPC instead of a write-only transaction.
+    #: Ignored in manual-transaction mode.
+    INGEST_BATCH_WRITE = "spanner.ingest.batch_write"
+    #: ``"true"`` runs the statement's DML as Partitioned DML: Spanner splits it
+    #: across partitions and applies each independently, so a large ``UPDATE`` or
+    #: ``DELETE`` never hits the per-commit mutation limit. Not atomic — a partition
+    #: may be applied more than once, so the statement must be idempotent — and
+    #: ``rowcount`` is a lower bound, not an exact count.
+    DML_PARTITIONED = "spanner.dml.partitioned"

spanner_adbc/_version.py

@@ -0,0 +1 @@
+__version__ = "0.8.0"

spanner_adbc/dbapi.py

@@ -0,0 +1,69 @@
+"""DBAPI 2.0 (PEP 249) interface for the Spanner ADBC driver.
+
+This is the layer most users want: it returns a standard DBAPI connection with
+cursors, plus the ADBC Arrow extensions (``fetch_arrow_table``, ``fetch_df``,
+``adbc_ingest``) that pandas / polars / DuckDB consume directly.
+
+    import spanner_adbc.dbapi as spanner
+    with spanner.connect(uri="spanner:///projects/p/instances/i/databases/d") as conn:
+        df = conn.cursor().execute("SELECT * FROM Singers").fetch_df()
+
+Note: DBAPI is autocommit-off by default, which puts this driver into its
+buffer-and-commit manual-transaction mode — call ``conn.commit()`` to apply DML.
+Pass ``autocommit=True`` to keep the driver's default single-statement mode.
+"""
+
+import typing
+
+import adbc_driver_manager.dbapi
+
+from . import (
+    ENTRYPOINT,
+    ConnectionOptions,
+    DatabaseOptions,
+    StatementOptions,
+    _driver_path,
+)
+
+__all__ = [
+    "connect",
+    "DatabaseOptions",
+    "ConnectionOptions",
+    "StatementOptions",
+]
+
+
+def connect(
+    db_kwargs: typing.Optional[typing.Mapping[str, str]] = None,
+    conn_kwargs: typing.Optional[typing.Mapping[str, str]] = None,
+    autocommit: bool = False,
+) -> adbc_driver_manager.dbapi.Connection:
+    """Open a DBAPI 2.0 connection to a Spanner database.
+
+    Parameters
+    ----------
+    db_kwargs:
+        Database-level driver options, keyed by their raw option strings — best
+        written with the :class:`DatabaseOptions` constants, e.g.
+        ``{DatabaseOptions.URI.value: "spanner:///projects/<p>/instances/<i>/databases/<d>"}``
+        (see src/lib.rs / docs/options.md). The ``uri`` option requires the
+        ``spanner://`` scheme; a bare database path is rejected. Credentials, the
+        emulator, endpoint overrides, and every other setting are passed here as
+        their raw keys — and the secret-holding ``KEYFILE_JSON`` / ``ACCESS_TOKEN``
+        options must be, since a ``uri`` may not carry them as query parameters.
+    conn_kwargs:
+        Connection-level options, keyed with the :class:`ConnectionOptions`
+        constants (``adbc.connection.*`` / ``spanner.*``).
+    autocommit:
+        Toggles PEP 249 autocommit; ``False`` (the default) puts the driver into
+        its buffer-and-commit manual-transaction mode.
+    """
+    # The driver manager builds and owns the database/connection handles here and
+    # tears them down if the connection fails, so no manual cleanup is needed.
+    return adbc_driver_manager.dbapi.connect(
+        driver=_driver_path(),
+        entrypoint=ENTRYPOINT,
+        db_kwargs=dict(db_kwargs) if db_kwargs else None,
+        conn_kwargs=conn_kwargs,
+        autocommit=autocommit,
+    )

spanner_adbc/manifest.py

@@ -0,0 +1,284 @@
+"""Generate and install an ADBC *driver manifest* for the bundled Spanner driver.
+
+A driver manifest is a small TOML file that lets any ADBC driver manager find a
+driver **by name** instead of by an explicit path to a shared library::
+
+    adbc_driver_manager.dbapi.connect(driver="spanner", uri="spanner:///...")
+
+and — because a driver manager with no ``driver`` option falls back to the
+*scheme* of the ``uri`` option, and this driver's connection URIs already use
+the ``spanner://`` scheme — by URI alone::
+
+    adbc_driver_manager.dbapi.connect(uri="spanner:///projects/p/instances/i/databases/d")
+
+See the ADBC specification, ``docs/source/format/driver_manifests.rst``.
+
+Why this is not a plain data file in the wheel
+----------------------------------------------
+
+The manifest's ``Driver.shared`` value is passed to ``dlopen``/``LoadLibraryExW``
+**verbatim**: neither the C nor the Rust driver manager resolves it relative to
+the manifest file. So a manifest must contain the *absolute* path of the shared
+library, which is only known once the wheel is installed. A manifest shipped
+pre-baked in the wheel would therefore point nowhere. Instead this module writes
+one at install time::
+
+    python -m spanner_adbc.manifest install
+    # or, equivalently, the console script:
+    spanner-adbc-install-manifest
+
+By default it writes to a directory the driver manager already searches (see
+:func:`default_install_dir`).
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import pathlib
+import platform
+import sys
+import sysconfig
+import typing
+
+from . import ENTRYPOINT, __version__, _driver_path
+
+__all__ = [
+    "MANIFEST_NAME",
+    "default_install_dir",
+    "install",
+    "manifest_text",
+    "platform_tuple",
+]
+
+#: The manifest's file name. The *base name* is what a driver manager matches
+#: against the driver name (and against a connection URI's scheme), so calling
+#: it anything else breaks ``driver="spanner"``.
+MANIFEST_NAME = "spanner.toml"
+
+# Architecture names from the spec's authoritative platform-tuple table, keyed by
+# the values `platform.machine()` reports. Only the architectures this project
+# builds for are listed; anything else is reported as an error rather than
+# guessed at.
+_ARCHES = {
+    "x86_64": "amd64",
+    "amd64": "amd64",
+    "aarch64": "arm64",
+    "arm64": "arm64",
+}
+
+_OSES = {
+    "linux": "linux",
+    "darwin": "macos",
+    "win32": "windows",
+    "cygwin": "windows",
+    "freebsd": "freebsd",
+    "openbsd": "openbsd",
+}
+
+
+def _is_musl() -> bool:
+    """Whether this interpreter runs against musl libc rather than glibc.
+
+    The driver manager appends ``_musl`` to the platform tuple when *it* was
+    compiled against musl. The driver manager reaching this code is the
+    ``adbc_driver_manager`` wheel installed next to this package, so it matches
+    the interpreter's own libc.
+    """
+    if sys.platform != "linux":
+        return False
+    # The platform tag is the most direct signal: CPython built on Alpine
+    # reports e.g. "linux-x86_64" but its wheel tags are musllinux_*, and
+    # `sysconfig.get_platform()` on a musl build carries "musl" on the
+    # distributions that set it.
+    if "musl" in (sysconfig.get_platform() or ""):
+        return True
+    try:
+        # glibc reports e.g. ("glibc", "2.35"); a musl build reports ("", "").
+        name, _version = platform.libc_ver()
+    except OSError:  # pragma: no cover - platform.libc_ver is very forgiving
+        return False
+    return not name
+
+
+def platform_tuple() -> str:
+    """The ``<os>_<arch>[_<env>]`` tuple the driver manager looks up.
+
+    Mirrors ``InternalAdbcCurrentArch()`` in the C driver manager
+    (``c/driver_manager/adbc_driver_manager.cc``) and ``arch_triplet()`` in the
+    Rust one.
+    """
+    os_name = _OSES.get(sys.platform)
+    if os_name is None and sys.platform.startswith("freebsd"):
+        os_name = "freebsd"
+    machine = platform.machine().lower()
+    arch = _ARCHES.get(machine)
+    if os_name is None or arch is None:
+        raise RuntimeError(
+            "spanner_adbc: cannot derive an ADBC platform tuple for "
+            f"sys.platform={sys.platform!r} machine={platform.machine()!r}; "
+            "this platform is not one the Spanner driver ships binaries for."
+        )
+    suffix = "_musl" if os_name == "linux" and _is_musl() else ""
+    return f"{os_name}_{arch}{suffix}"
+
+
+def _toml_string(value: str) -> str:
+    """Render a TOML basic string.
+
+    Basic (double-quoted) strings are used rather than literal ones because a
+    Windows install path contains backslashes *and* may contain a single quote,
+    which a TOML literal string cannot escape.
+    """
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def manifest_text(library: typing.Union[str, "os.PathLike[str]", None] = None) -> str:
+    """Render a driver manifest for this installation.
+
+    Parameters
+    ----------
+    library:
+        Absolute path to the driver shared library. Defaults to the library
+        bundled in this wheel.
+
+    Notes
+    -----
+    ``Driver.shared`` is emitted as a plain *string* rather than a table of
+    platform tuples. The spec allows either ("``Driver.shared`` ... must either
+    be a string (single path) or a table of platform-specific paths"), and a
+    manifest generated for one installed wheel describes exactly one platform,
+    so the string form cannot disagree with the driver manager about how this
+    platform is spelled.
+    """
+    path = pathlib.Path(library) if library is not None else pathlib.Path(_driver_path())
+    path = path.resolve()
+    return f"""\
+# ADBC driver manifest for Google Cloud Spanner.
+#
+# Generated by `python -m spanner_adbc.manifest install` for the library
+# bundled in the spanner-adbc wheel. Regenerate it after upgrading,
+# reinstalling or moving the Python environment: the path below is absolute and
+# is passed to the dynamic loader verbatim.
+#
+# Platform tuple at generation time: {platform_tuple()}
+
+manifest_version = 1
+
+name = "Google Cloud Spanner"
+publisher = "fornwall"
+license = "Apache-2.0"
+version = {_toml_string(__version__)}
+url = "https://github.com/fornwall/spanner-adbc"
+source = "spanner-adbc (Python wheel)"
+
+[ADBC]
+version = "1.1.0"
+
+[Driver]
+entrypoint = {_toml_string(ENTRYPOINT)}
+shared = {_toml_string(str(path))}
+"""
+
+
+def default_install_dir() -> pathlib.Path:
+    """The directory to install the manifest into by default.
+
+    Inside a virtual environment this is ``<sys.prefix>/etc/adbc/drivers``,
+    which the Python driver manager adds to its search paths automatically
+    (``adbc_driver_manager/_lib.pyx`` does this whenever
+    ``sys.prefix != sys.base_prefix``). That keeps the manifest scoped to the
+    same environment as the wheel it points into.
+
+    Outside a venv it is the driver manager's *user* config directory, which is
+    searched when the ``SEARCH_USER`` load flag is set (it is, by default):
+
+    * Linux: ``$XDG_CONFIG_HOME/adbc/drivers``, else ``~/.config/adbc/drivers``
+    * macOS: ``~/Library/Application Support/ADBC/Drivers``
+    * Windows: ``%LOCALAPPDATA%\\ADBC\\Drivers``
+    """
+    if sys.prefix != sys.base_prefix:
+        return pathlib.Path(sys.prefix) / "etc" / "adbc" / "drivers"
+
+    if sys.platform == "win32":
+        local = os.environ.get("LOCALAPPDATA")
+        if not local:
+            raise RuntimeError(
+                "spanner_adbc: %LOCALAPPDATA% is not set, so the driver "
+                "manager's user config directory cannot be located; pass an "
+                "explicit directory instead."
+            )
+        return pathlib.Path(local) / "ADBC" / "Drivers"
+
+    if sys.platform == "darwin":
+        return pathlib.Path.home() / "Library" / "Application Support" / "ADBC" / "Drivers"
+
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    base = pathlib.Path(xdg) if xdg else pathlib.Path.home() / ".config"
+    return base / "adbc" / "drivers"
+
+
+def install(
+    directory: typing.Union[str, "os.PathLike[str]", None] = None,
+    *,
+    library: typing.Union[str, "os.PathLike[str]", None] = None,
+) -> pathlib.Path:
+    """Write ``spanner.toml`` into *directory* and return the path written.
+
+    *directory* defaults to :func:`default_install_dir` and is created if it
+    does not exist. An existing manifest is overwritten, so re-running this
+    after an upgrade is the supported way to refresh a stale path.
+    """
+    target_dir = pathlib.Path(directory) if directory is not None else default_install_dir()
+    target_dir.mkdir(parents=True, exist_ok=True)
+    target = target_dir / MANIFEST_NAME
+    target.write_text(manifest_text(library), encoding="utf-8")
+    return target
+
+
+def main(argv: typing.Optional[typing.Sequence[str]] = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="python -m spanner_adbc.manifest",
+        description=(
+            "Install an ADBC driver manifest so the Spanner driver resolves by "
+            'name (driver="spanner") or by URI scheme (uri="spanner:///...").'
+        ),
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_install = sub.add_parser("install", help="write the manifest (default)")
+    p_install.add_argument(
+        "-d",
+        "--dir",
+        dest="directory",
+        default=None,
+        help=(
+            f"directory to write {MANIFEST_NAME} into (default: a directory the "
+            "driver manager searches; see the `path` subcommand)"
+        ),
+    )
+    sub.add_parser("print", help="print the manifest to stdout without writing it")
+    sub.add_parser("path", help="print the default install path and exit")
+
+    args = parser.parse_args(argv)
+    command = args.command or "install"
+
+    if command == "print":
+        sys.stdout.write(manifest_text())
+        return 0
+    if command == "path":
+        print(default_install_dir() / MANIFEST_NAME)
+        return 0
+
+    written = install(getattr(args, "directory", None))
+    print(f"Wrote {written}")
+    print(
+        'The Spanner driver now resolves as driver="spanner" and from '
+        'uri="spanner:///..." for this environment.'
+    )
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover - exercised via the console script
+    raise SystemExit(main())

spanner_adbc-0.8.0.dist-info/METADATA

@@ -0,0 +1,361 @@
+Metadata-Version: 2.4
+Name: spanner-adbc
+Version: 0.8.0
+Summary: ADBC (Arrow Database Connectivity) driver for Google Cloud Spanner
+Author-email: Fredrik Fornwall <fredrik@fornwall.net>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/fornwall/spanner-adbc
+Project-URL: Repository, https://github.com/fornwall/spanner-adbc
+Keywords: adbc,arrow,spanner,database,gcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Database
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: adbc-driver-manager>=1.0
+Provides-Extra: dbapi
+Requires-Dist: adbc-driver-manager[dbapi]>=1.0; extra == "dbapi"
+Requires-Dist: pyarrow>=14.0.1; extra == "dbapi"
+Dynamic: license-file
+
+# spanner-adbc
+
+[![PyPI version](https://img.shields.io/pypi/v/spanner-adbc.svg)](https://pypi.org/project/spanner-adbc/)
+[![Python versions](https://img.shields.io/pypi/pyversions/spanner-adbc.svg)](https://pypi.org/project/spanner-adbc/)
+[![Wheel](https://img.shields.io/pypi/wheel/spanner-adbc.svg)](https://pypi.org/project/spanner-adbc/#files)
+[![License](https://img.shields.io/pypi/l/spanner-adbc.svg)](https://github.com/fornwall/spanner-adbc/blob/main/LICENSE)
+[![Build](https://github.com/fornwall/spanner-adbc/actions/workflows/libraries.yml/badge.svg)](https://github.com/fornwall/spanner-adbc/actions/workflows/libraries.yml)
+
+A Python [ADBC](https://arrow.apache.org/adbc/) driver for **Google Cloud Spanner**.
+
+Query Spanner through [DBAPI 2.0](https://peps.python.org/pep-0249/) and fetch
+[Apache Arrow](https://arrow.apache.org/) results for pandas, Polars, DuckDB, or PyArrow.
+
+## Install
+
+Requires Python 3.11 or later. Wheels bundle the native driver; see
+[Supported platforms](#supported-platforms) for OS requirements.
+
+```sh
+pip install "spanner-adbc[dbapi]"  # includes PyArrow and pandas
+```
+
+For the low-level ADBC API without DataFrame dependencies, install `spanner-adbc`.
+The Python import name is `spanner_adbc`.
+
+## Quickstart
+
+This example assumes an existing `Singers` table with `SingerId` and `FirstName` columns.
+
+```python
+import spanner_adbc.dbapi as spanner
+from spanner_adbc import DatabaseOptions
+
+with spanner.connect(
+    db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/my-project/instances/my-instance/databases/my-db"},
+) as conn:
+    with conn.cursor() as cur:
+        cur.execute("SELECT SingerId, FirstName FROM Singers")
+        df = cur.fetch_df()          # -> pandas.DataFrame
+```
+
+Use GoogleSQL `@name` parameters with `cur.execute(...)`; `?` placeholders are unsupported.
+`fetchone()` and `fetchall()` return Python rows; Arrow and DataFrame helpers are shown below.
+
+## Driver manifest (`driver="spanner"`)
+
+The package's `spanner.connect()` loads its bundled library directly. To use the generic
+`adbc_driver_manager` by driver name, install an [ADBC driver manifest][manifests].
+Use a current driver manager; Python manifest support requires
+[version 1.8.0 or later](https://arrow.apache.org/blog/2025/09/12/adbc-20-release/).
+
+```sh
+pip install --upgrade adbc-driver-manager
+python -m spanner_adbc.manifest install
+```
+
+The equivalent console command is `spanner-adbc-install-manifest`.
+
+```python docs-test: skip
+import adbc_driver_manager.dbapi
+
+with adbc_driver_manager.dbapi.connect(
+    driver="spanner",
+    uri="spanner:///projects/my-project/instances/my-instance/databases/my-db",
+) as conn:
+    ...
+```
+
+Current driver managers can also infer `spanner` from the URI scheme when `driver` is omitted.
+
+- Re-run the installer after upgrading, reinstalling, or moving the environment: the manifest
+  contains the library's absolute path.
+- The default directory is `<sys.prefix>/etc/adbc/drivers` inside a virtual environment, or the
+  platform's user configuration directory otherwise. `python -m spanner_adbc.manifest path`
+  prints the target path.
+- Use `install --dir /path/to/drivers` for a custom directory on `ADBC_DRIVER_PATH`.
+- For a standalone shared library, edit the `Driver.shared` paths in the repository's
+  [spanner.toml][manifest-file].
+
+[manifests]: https://arrow.apache.org/adbc/current/format/driver_manifests.html
+[manifest-file]: https://github.com/fornwall/spanner-adbc/blob/main/spanner.toml
+
+## Authentication
+
+With no credential options, the driver uses
+[Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials):
+run `gcloud auth application-default login` locally, set `GOOGLE_APPLICATION_CREDENTIALS`, or use
+an attached service account on Google Cloud.
+
+Pass explicit credentials in `db_kwargs` alongside `DatabaseOptions.URI.value`:
+
+| Option | Value |
+| --- | --- |
+| `DatabaseOptions.KEYFILE` | Credential JSON file path |
+| `DatabaseOptions.KEYFILE_JSON` | Credential JSON contents |
+| `DatabaseOptions.ACCESS_TOKEN` | OAuth bearer token; never refreshed |
+| `DatabaseOptions.IMPERSONATE_TARGET_PRINCIPAL` | Service account to impersonate using ADC or explicit base credentials |
+
+Use each enum member's `.value` as the key. `ACCESS_TOKEN` cannot be combined with key-file
+credentials or impersonation. See the [option reference][options] for scopes and other auth settings.
+
+For the [Spanner emulator](https://cloud.google.com/spanner/docs/emulator), use anonymous mode:
+
+```python docs-test: skip
+import spanner_adbc.dbapi as spanner
+from spanner_adbc import DatabaseOptions
+
+with spanner.connect(db_kwargs={
+    DatabaseOptions.URI.value: "spanner:///projects/p/instances/i/databases/d",
+    DatabaseOptions.ENDPOINT.value: "localhost:9010",
+    DatabaseOptions.EMULATOR.value: "true",
+}) as conn:
+    ...
+```
+
+Emulator mode rejects explicit credential options; ambient ADC is ignored.
+
+## Options
+
+| `connect()` argument | Purpose |
+| --- | --- |
+| `db_kwargs` | Database options, including the required `uri` |
+| `conn_kwargs` | Connection options |
+| `autocommit` | `False` by default; see [Transactions](#transactions) |
+
+Use `DatabaseOptions`, `ConnectionOptions`, and `StatementOptions` enums, or raw option keys.
+The [option reference][options] lists types, defaults, and accepted values. Set cursor options with
+`conn.cursor(adbc_stmt_kwargs={...})` or `cur.adbc_statement.set_options(**{...})`.
+
+[options]: https://github.com/fornwall/spanner-adbc/blob/main/docs/options.md
+
+```python
+import spanner_adbc.dbapi as spanner
+from spanner_adbc import ConnectionOptions, DatabaseOptions, StatementOptions
+
+with spanner.connect(
+    db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/p/instances/i/databases/d"},
+    conn_kwargs={ConnectionOptions.READ_STALENESS.value: "max:10s"},
+    autocommit=True,  # bounded staleness on a single-use read
+) as conn:
+    with conn.cursor(
+        adbc_stmt_kwargs={StatementOptions.ROWS_PER_BATCH.value: "1024"}
+    ) as cur:
+        cur.execute("SELECT * FROM Singers")
+```
+
+In manual query transactions, `max:<duration>` and `min:<timestamp>` bounds become exact
+staleness and a fixed read timestamp respectively. Set `ConnectionOptions.READONLY.value` to
+`"true"` to reject DML, DDL, and ingest; rollback remains available.
+
+## Transactions
+
+DBAPI defaults to `autocommit=False`. A manual transaction accepts either queries or writes,
+chosen by its first query or write; mixing them raises `adbc_driver_manager.ProgrammingError` until
+commit or rollback. Queries share a snapshot. DML is buffered until `conn.commit()`, so queries
+cannot read buffered writes.
+
+DDL always executes immediately: rollback cannot undo it, and it runs before buffered DML.
+Use `autocommit=True` for immediately committed DML, including `THEN RETURN` statements.
+See [transactions](https://github.com/fornwall/spanner-adbc/blob/main/docs/transactions.md) for
+bulk-ingest and partitioned-DML behavior.
+
+```python
+import spanner_adbc.dbapi as spanner
+from adbc_driver_manager import ProgrammingError
+from spanner_adbc import DatabaseOptions
+
+with spanner.connect(
+    db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/my-project/instances/my-instance/databases/my-db"},
+) as conn:
+    with conn.cursor() as cur:
+        # DDL applies immediately.
+        cur.execute("DROP TABLE IF EXISTS Albums")
+        cur.execute("CREATE TABLE Albums (Id INT64 NOT NULL) PRIMARY KEY (Id)")
+
+        cur.execute("INSERT INTO Albums (Id) VALUES (1)")  # a DML transaction: buffered
+        # Commit before querying the inserted row.
+        try:
+            cur.execute("SELECT COUNT(*) FROM Albums")
+            raise AssertionError("expected the guarded query to raise")
+        except ProgrammingError:
+            pass
+    conn.commit()
+
+    with conn.cursor() as cur:
+        cur.execute("SELECT COUNT(*) FROM Albums")
+        assert cur.fetchone()[0] == 1
+    conn.rollback()  # end the query snapshot
+```
+
+## Working with DataFrames
+
+The quickstart uses pandas. The examples below use the same `Singers` table with `SingerId` and
+`FirstName` columns. Install `polars` or `duckdb` separately for those examples.
+
+**pyarrow — results as a native Arrow table:**
+
+```python
+import spanner_adbc.dbapi as spanner
+from spanner_adbc import DatabaseOptions
+
+with spanner.connect(
+    db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/my-project/instances/my-instance/databases/my-db"},
+) as conn:
+    with conn.cursor() as cur:
+        cur.execute("SELECT SingerId, FirstName FROM Singers ORDER BY SingerId")
+        table = cur.fetch_arrow_table()      # -> pyarrow.Table
+```
+
+**polars — read straight from the connection:**
+
+```python
+import polars as pl
+import spanner_adbc.dbapi as spanner
+from spanner_adbc import DatabaseOptions
+
+with spanner.connect(
+    db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/my-project/instances/my-instance/databases/my-db"},
+) as conn:
+    df = pl.read_database(
+        "SELECT SingerId, FirstName FROM Singers ORDER BY SingerId",
+        connection=conn,                     # an ADBC connection, not a URI
+    )
+```
+
+**DuckDB — query the fetched Arrow table in-process:**
+
+```python
+import duckdb
+import spanner_adbc.dbapi as spanner
+from spanner_adbc import DatabaseOptions
+
+with spanner.connect(
+    db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/my-project/instances/my-instance/databases/my-db"},
+) as conn:
+    with conn.cursor() as cur:
+        cur.execute("SELECT SingerId, FirstName FROM Singers")
+        singers = cur.fetch_arrow_table()
+
+# DuckDB can query the Arrow table by variable name.
+top = duckdb.sql("SELECT COUNT(*) AS n, MIN(FirstName) AS first FROM singers").fetchone()
+```
+
+## Bulk insert a DataFrame
+
+`cur.adbc_ingest(table, data, mode=...)` inserts Arrow-compatible data in bulk. Convert pandas
+DataFrames to Arrow as shown here:
+
+```python
+import pandas as pd
+import pyarrow as pa
+import spanner_adbc.dbapi as spanner
+from spanner_adbc import DatabaseOptions
+
+frame = pd.DataFrame({"SingerId": [10, 11], "FirstName": ["Carol", "Dave"]})
+
+with spanner.connect(
+    db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/my-project/instances/my-instance/databases/my-db"},
+    autocommit=True,                         # apply immediately; returns the row count
+) as conn:
+    with conn.cursor() as cur:
+        # `append` inserts into an existing table (the default mode is `create`).
+        rows = cur.adbc_ingest("Singers", pa.Table.from_pandas(frame), mode="append")
+```
+
+The `mode` selects how the target table is handled:
+
+- `create` — create the table from the data's Arrow schema first, erroring if it already exists (the default).
+- `append` — insert into an existing table.
+- `create_append` — create the table only if it is absent, then insert.
+- `replace` — drop any existing table, recreate it from the schema, then insert.
+
+Create modes omit a primary key, so Spanner supplies a [hidden `rowid` column][no-pk].
+For an explicit primary key, create the table with SQL first and use `mode="append"`.
+In manual mode, inserts need `conn.commit()`; table creation or replacement still happens immediately.
+Autocommit loads may commit in multiple chunks, so a failed load can leave rows written.
+
+[no-pk]: https://cloud.google.com/spanner/docs/primary-key-default-value#tables-without-primary-keys
+
+## Partitioned reads and Data Boost
+
+A large scan can be split into independent partitions and read in parallel — optionally on Spanner's
+serverless [Data Boost] compute, so the work is isolated from your provisioned instance. This uses
+the ADBC partitioned-execution extension (`adbc_execute_partitions` / `adbc_read_partition`):
+
+```python
+import spanner_adbc.dbapi as spanner
+from spanner_adbc import DatabaseOptions, StatementOptions
+
+with spanner.connect(
+    db_kwargs={DatabaseOptions.URI.value: "spanner:///projects/my-project/instances/my-instance/databases/my-db"},
+) as conn:
+    with conn.cursor() as cur:
+        # Optional statement options, set on the underlying ADBC statement:
+        cur.adbc_statement.set_options(**{
+            StatementOptions.DATA_BOOST.value: "true",  # run on Data Boost
+        })
+        partitions, schema = cur.adbc_execute_partitions("SELECT SingerId FROM Singers")
+
+    # Each descriptor is opaque bytes; it can be shipped to another worker,
+    # process, or connection and read independently.
+    for token in partitions:
+        with conn.cursor() as cur:
+            cur.adbc_read_partition(token)
+            table = cur.fetch_arrow_table()
+            ...
+```
+
+Spanner decides partitionability from the query plan. Simple scans are suitable; joins, ordering,
+and aggregation can prevent partitioning. See the [partitionability rules][parallel-reads].
+
+Descriptors contain SQL and transaction identifiers and are unauthenticated. Only read descriptors
+from trusted sources: they execute using the receiving connection's credentials.
+
+[Data Boost]: https://cloud.google.com/spanner/docs/databoost/databoost-overview
+[parallel-reads]: https://cloud.google.com/spanner/docs/reads#read_data_in_parallel
+
+## Supported platforms
+
+`pip` selects a wheel matching the OS and architecture:
+
+| Platform       | Wheel tag                | Minimum requirement                          |
+| -------------- | ------------------------ | -------------------------------------------- |
+| Linux x86-64   | `manylinux_2_35_x86_64`  | glibc >= 2.35 |
+| Linux aarch64  | `manylinux_2_35_aarch64` | glibc >= 2.35 |
+| Linux x86-64 musl | `musllinux_1_2_x86_64` | musl libc >= 1.2 |
+| Linux aarch64 musl | `musllinux_1_2_aarch64` | musl libc >= 1.2 |
+| macOS arm64    | `macosx_11_0_arm64`      | macOS >= 11.0                                |
+| macOS x86-64   | `macosx_10_15_x86_64`    | macOS >= 10.15                               |
+| Windows x86-64 | `win_amd64`              | 64-bit Windows                               |
+| Windows arm64  | `win_arm64`              | ARM64 Windows                                |
+
+Building for an older OS requires a compatible native driver and Python dependencies.
+For local builds and releases, see [CONTRIBUTING.md](https://github.com/fornwall/spanner-adbc/blob/main/CONTRIBUTING.md).

spanner_adbc-0.8.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+spanner_adbc/__init__.py,sha256=JaM_rJCT-CHATYa7-uJ8YwPUbbiYGbGRw-smVB_B6nw,3131
+spanner_adbc/_options.py,sha256=E7CmaEoTXI2aTdeqcezKCm8NpabOdIk-w9mIHztr6-A,10169
+spanner_adbc/_version.py,sha256=iPlYCcIzuzW7T2HKDkmYlMkRI51dBLfNRxPPiWrfw9U,22
+spanner_adbc/dbapi.py,sha256=386EflvG4UZuOhAuPXurbaR4IS7YLZJ4PKx3JjAQm48,2676
+spanner_adbc/manifest.py,sha256=gzkRLvApR8Qr_pSOt3eJ28exp8UuwH38EbhiNgjNFF8,10214
+spanner_adbc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spanner_adbc/spanner_adbc.dll,sha256=WNceT_RFScRiNq3zIVl1XVskAVQpuVhevnUrJTh_ib8,19527168
+spanner_adbc-0.8.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+spanner_adbc-0.8.0.dist-info/METADATA,sha256=swV8k52jxUjSLmpSrShJHl4vE7DX4yTMTJQ2dwMEA-8,15354
+spanner_adbc-0.8.0.dist-info/WHEEL,sha256=Zx98gwb_dQKckJK3HEOVKnxxD52EfU_PXDG_usMJ2ng,98
+spanner_adbc-0.8.0.dist-info/entry_points.txt,sha256=S9FfsSQaBxlssjyACrt16kcxWdYq3ptxDVXCuYkCF58,77
+spanner_adbc-0.8.0.dist-info/top_level.txt,sha256=sBmJlDBf448Pz4G5lANkoLq6qyRvZ8tawyxyOqDmlFk,13
+spanner_adbc-0.8.0.dist-info/RECORD,,

spanner_adbc-0.8.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

spanner_adbc-0.8.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+spanner-adbc-install-manifest = spanner_adbc.manifest:main

spanner_adbc-0.8.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

spanner_adbc-0.8.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+spanner_adbc