Add files using upload-large-folder tool

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/dbapi/__init__.py

@@ -0,0 +1,87 @@
+# Copyright 2017 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.
+
+"""Google BigQuery implementation of the Database API Specification v2.0.
+
+This module implements the `Python Database API Specification v2.0 (DB-API)`_
+for Google BigQuery.
+
+.. _Python Database API Specification v2.0 (DB-API):
+   https://www.python.org/dev/peps/pep-0249/
+"""
+
+from google.cloud.bigquery.dbapi.connection import connect
+from google.cloud.bigquery.dbapi.connection import Connection
+from google.cloud.bigquery.dbapi.cursor import Cursor
+from google.cloud.bigquery.dbapi.exceptions import Warning
+from google.cloud.bigquery.dbapi.exceptions import Error
+from google.cloud.bigquery.dbapi.exceptions import InterfaceError
+from google.cloud.bigquery.dbapi.exceptions import DatabaseError
+from google.cloud.bigquery.dbapi.exceptions import DataError
+from google.cloud.bigquery.dbapi.exceptions import OperationalError
+from google.cloud.bigquery.dbapi.exceptions import IntegrityError
+from google.cloud.bigquery.dbapi.exceptions import InternalError
+from google.cloud.bigquery.dbapi.exceptions import ProgrammingError
+from google.cloud.bigquery.dbapi.exceptions import NotSupportedError
+from google.cloud.bigquery.dbapi.types import Binary
+from google.cloud.bigquery.dbapi.types import Date
+from google.cloud.bigquery.dbapi.types import DateFromTicks
+from google.cloud.bigquery.dbapi.types import Time
+from google.cloud.bigquery.dbapi.types import TimeFromTicks
+from google.cloud.bigquery.dbapi.types import Timestamp
+from google.cloud.bigquery.dbapi.types import TimestampFromTicks
+from google.cloud.bigquery.dbapi.types import BINARY
+from google.cloud.bigquery.dbapi.types import DATETIME
+from google.cloud.bigquery.dbapi.types import NUMBER
+from google.cloud.bigquery.dbapi.types import ROWID
+from google.cloud.bigquery.dbapi.types import STRING
+
+
+apilevel = "2.0"
+
+# Threads may share the module and connections, but not cursors.
+threadsafety = 2
+
+paramstyle = "pyformat"
+
+__all__ = [
+    "apilevel",
+    "threadsafety",
+    "paramstyle",
+    "connect",
+    "Connection",
+    "Cursor",
+    "Warning",
+    "Error",
+    "InterfaceError",
+    "DatabaseError",
+    "DataError",
+    "OperationalError",
+    "IntegrityError",
+    "InternalError",
+    "ProgrammingError",
+    "NotSupportedError",
+    "Binary",
+    "Date",
+    "DateFromTicks",
+    "Time",
+    "TimeFromTicks",
+    "Timestamp",
+    "TimestampFromTicks",
+    "BINARY",
+    "DATETIME",
+    "NUMBER",
+    "ROWID",
+    "STRING",
+]

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/dbapi/_helpers.py

@@ -0,0 +1,522 @@
+# Copyright 2017 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 collections import abc as collections_abc
+import datetime
+import decimal
+import functools
+import numbers
+import re
+import typing
+
+from google.cloud import bigquery
+from google.cloud.bigquery import table, query
+from google.cloud.bigquery.dbapi import exceptions
+
+
+_NUMERIC_SERVER_MIN = decimal.Decimal("-9.9999999999999999999999999999999999999E+28")
+_NUMERIC_SERVER_MAX = decimal.Decimal("9.9999999999999999999999999999999999999E+28")
+
+type_parameters_re = re.compile(
+    r"""
+    \(
+    \s*[0-9]+\s*
+    (,
+    \s*[0-9]+\s*
+    )*
+    \)
+    """,
+    re.VERBOSE,
+)
+
+
+def _parameter_type(name, value, query_parameter_type=None, value_doc=""):
+    if query_parameter_type:
+        # Strip type parameters
+        query_parameter_type = type_parameters_re.sub("", query_parameter_type)
+        try:
+            parameter_type = getattr(
+                query.SqlParameterScalarTypes, query_parameter_type.upper()
+            )._type
+        except AttributeError:
+            raise exceptions.ProgrammingError(
+                f"The given parameter type, {query_parameter_type},"
+                f" for {name} is not a valid BigQuery scalar type."
+            )
+    else:
+        parameter_type = bigquery_scalar_type(value)
+        if parameter_type is None:
+            raise exceptions.ProgrammingError(
+                f"Encountered parameter {name} with "
+                f"{value_doc} value {value} of unexpected type."
+            )
+    return parameter_type
+
+
+def scalar_to_query_parameter(value, name=None, query_parameter_type=None):
+    """Convert a scalar value into a query parameter.
+
+    Args:
+        value (Any):
+            A scalar value to convert into a query parameter.
+
+        name (str):
+            (Optional) Name of the query parameter.
+        query_parameter_type (Optional[str]): Given type for the parameter.
+
+    Returns:
+        google.cloud.bigquery.ScalarQueryParameter:
+            A query parameter corresponding with the type and value of the plain
+            Python object.
+
+    Raises:
+        google.cloud.bigquery.dbapi.exceptions.ProgrammingError:
+            if the type cannot be determined.
+    """
+    return bigquery.ScalarQueryParameter(
+        name, _parameter_type(name, value, query_parameter_type), value
+    )
+
+
+def array_to_query_parameter(value, name=None, query_parameter_type=None):
+    """Convert an array-like value into a query parameter.
+
+    Args:
+        value (Sequence[Any]): The elements of the array (should not be a
+            string-like Sequence).
+        name (Optional[str]): Name of the query parameter.
+        query_parameter_type (Optional[str]): Given type for the parameter.
+
+    Returns:
+        A query parameter corresponding with the type and value of the plain
+        Python object.
+
+    Raises:
+        google.cloud.bigquery.dbapi.exceptions.ProgrammingError:
+            if the type of array elements cannot be determined.
+    """
+    if not array_like(value):
+        raise exceptions.ProgrammingError(
+            "The value of parameter {} must be a sequence that is "
+            "not string-like.".format(name)
+        )
+
+    if query_parameter_type or value:
+        array_type = _parameter_type(
+            name,
+            value[0] if value else None,
+            query_parameter_type,
+            value_doc="array element ",
+        )
+    else:
+        raise exceptions.ProgrammingError(
+            "Encountered an empty array-like value of parameter {}, cannot "
+            "determine array elements type.".format(name)
+        )
+
+    return bigquery.ArrayQueryParameter(name, array_type, value)
+
+
+def _parse_struct_fields(
+    fields,
+    base,
+    parse_struct_field=re.compile(
+        r"""
+        (?:(\w+)\s+)    # field name
+        ([A-Z0-9<> ,()]+)  # Field type
+        $""",
+        re.VERBOSE | re.IGNORECASE,
+    ).match,
+):
+    # Split a string of struct fields.  They're defined by commas, but
+    # we have to avoid splitting on commas internal to fields.  For
+    # example:
+    # name string, children array<struct<name string, bdate date>>
+    #
+    # only has 2 top-level fields.
+    fields = fields.split(",")
+    fields = list(reversed(fields))  # in the off chance that there are very many
+    while fields:
+        field = fields.pop()
+        while fields and field.count("<") != field.count(">"):
+            field += "," + fields.pop()
+
+        m = parse_struct_field(field.strip())
+        if not m:
+            raise exceptions.ProgrammingError(
+                f"Invalid struct field, {field}, in {base}"
+            )
+        yield m.group(1, 2)
+
+
+SCALAR, ARRAY, STRUCT = ("s", "a", "r")
+
+
+def _parse_type(
+    type_,
+    name,
+    base,
+    complex_query_parameter_parse=re.compile(
+        r"""
+        \s*
+        (ARRAY|STRUCT|RECORD)  # Type
+        \s*
+        <([A-Z0-9_<> ,()]+)>   # Subtype(s)
+        \s*$
+        """,
+        re.IGNORECASE | re.VERBOSE,
+    ).match,
+):
+    if "<" not in type_:
+        # Scalar
+
+        # Strip type parameters
+        type_ = type_parameters_re.sub("", type_).strip()
+        try:
+            type_ = getattr(query.SqlParameterScalarTypes, type_.upper())
+        except AttributeError:
+            raise exceptions.ProgrammingError(
+                f"The given parameter type, {type_},"
+                f"{' for ' + name if name else ''}"
+                f" is not a valid BigQuery scalar type, in {base}."
+            )
+        if name:
+            type_ = type_.with_name(name)
+        return SCALAR, type_
+
+    m = complex_query_parameter_parse(type_)
+    if not m:
+        raise exceptions.ProgrammingError(f"Invalid parameter type, {type_}")
+    tname, sub = m.group(1, 2)
+    if tname.upper() == "ARRAY":
+        sub_type = complex_query_parameter_type(None, sub, base)
+        if isinstance(sub_type, query.ArrayQueryParameterType):
+            raise exceptions.ProgrammingError(f"Array can't contain an array in {base}")
+        sub_type._complex__src = sub
+        return ARRAY, sub_type
+    else:
+        return STRUCT, _parse_struct_fields(sub, base)
+
+
+def complex_query_parameter_type(name: typing.Optional[str], type_: str, base: str):
+    """Construct a parameter type (`StructQueryParameterType`) for a complex type
+
+    or a non-complex type that's part of a complex type.
+
+    Examples:
+
+    array<struct<x float64, y float64>>
+
+    struct<name string, children array<struct<name string, bdate date>>>
+
+    This is used for computing array types.
+    """
+
+    type_type, sub_type = _parse_type(type_, name, base)
+    if type_type == SCALAR:
+        result_type = sub_type
+    elif type_type == ARRAY:
+        result_type = query.ArrayQueryParameterType(sub_type, name=name)
+    elif type_type == STRUCT:
+        fields = [
+            complex_query_parameter_type(field_name, field_type, base)
+            for field_name, field_type in sub_type
+        ]
+        result_type = query.StructQueryParameterType(*fields, name=name)
+    else:  # pragma: NO COVER
+        raise AssertionError("Bad type_type", type_type)  # Can't happen :)
+
+    return result_type
+
+
+def complex_query_parameter(
+    name: typing.Optional[str], value, type_: str, base: typing.Optional[str] = None
+):
+    """
+    Construct a query parameter for a complex type (array or struct record)
+
+    or for a subtype, which may not be complex
+
+    Examples:
+
+    array<struct<x float64, y float64>>
+
+    struct<name string, children array<struct<name string, bdate date>>>
+
+    """
+    param: typing.Union[
+        query.ScalarQueryParameter,
+        query.ArrayQueryParameter,
+        query.StructQueryParameter,
+    ]
+
+    base = base or type_
+
+    type_type, sub_type = _parse_type(type_, name, base)
+
+    if type_type == SCALAR:
+        param = query.ScalarQueryParameter(name, sub_type._type, value)
+    elif type_type == ARRAY:
+        if not array_like(value):
+            raise exceptions.ProgrammingError(
+                f"Array type with non-array-like value"
+                f" with type {type(value).__name__}"
+            )
+        param = query.ArrayQueryParameter(
+            name,
+            sub_type,
+            (
+                value
+                if isinstance(sub_type, query.ScalarQueryParameterType)
+                else [
+                    complex_query_parameter(None, v, sub_type._complex__src, base)
+                    for v in value
+                ]
+            ),
+        )
+    elif type_type == STRUCT:
+        if not isinstance(value, collections_abc.Mapping):
+            raise exceptions.ProgrammingError(f"Non-mapping value for type {type_}")
+        value_keys = set(value)
+        fields = []
+        for field_name, field_type in sub_type:
+            if field_name not in value:
+                raise exceptions.ProgrammingError(
+                    f"No field value for {field_name} in {type_}"
+                )
+            value_keys.remove(field_name)
+            fields.append(
+                complex_query_parameter(field_name, value[field_name], field_type, base)
+            )
+        if value_keys:
+            raise exceptions.ProgrammingError(f"Extra data keys for {type_}")
+
+        param = query.StructQueryParameter(name, *fields)
+    else:  # pragma: NO COVER
+        raise AssertionError("Bad type_type", type_type)  # Can't happen :)
+
+    return param
+
+
+def _dispatch_parameter(type_, value, name=None):
+    if type_ is not None and "<" in type_:
+        param = complex_query_parameter(name, value, type_)
+    elif isinstance(value, collections_abc.Mapping):
+        raise NotImplementedError(
+            f"STRUCT-like parameter values are not supported"
+            f"{' (parameter ' + name + ')' if name else ''},"
+            f" unless an explicit type is give in the parameter placeholder"
+            f" (e.g. '%({name if name else ''}:struct<...>)s')."
+        )
+    elif array_like(value):
+        param = array_to_query_parameter(value, name, type_)
+    else:
+        param = scalar_to_query_parameter(value, name, type_)
+
+    return param
+
+
+def to_query_parameters_list(parameters, parameter_types):
+    """Converts a sequence of parameter values into query parameters.
+
+    Args:
+        parameters (Sequence[Any]): Sequence of query parameter values.
+        parameter_types:
+            A list of parameter types, one for each parameter.
+            Unknown types are provided as None.
+
+    Returns:
+        List[google.cloud.bigquery.query._AbstractQueryParameter]:
+            A list of query parameters.
+    """
+    return [
+        _dispatch_parameter(type_, value)
+        for value, type_ in zip(parameters, parameter_types)
+    ]
+
+
+def to_query_parameters_dict(parameters, query_parameter_types):
+    """Converts a dictionary of parameter values into query parameters.
+
+    Args:
+        parameters (Mapping[str, Any]): Dictionary of query parameter values.
+        parameter_types:
+            A dictionary of parameter types. It needn't have a key for each
+            parameter.
+
+    Returns:
+        List[google.cloud.bigquery.query._AbstractQueryParameter]:
+            A list of named query parameters.
+    """
+    return [
+        _dispatch_parameter(query_parameter_types.get(name), value, name)
+        for name, value in parameters.items()
+    ]
+
+
+def to_query_parameters(parameters, parameter_types):
+    """Converts DB-API parameter values into query parameters.
+
+    Args:
+        parameters (Union[Mapping[str, Any], Sequence[Any]]):
+            A dictionary or sequence of query parameter values.
+        parameter_types (Union[Mapping[str, str], Sequence[str]]):
+            A dictionary or list of parameter types.
+
+            If parameters is a mapping, then this must be a dictionary
+            of parameter types.  It needn't have a key for each
+            parameter.
+
+            If parameters is a sequence, then this must be a list of
+            parameter types, one for each paramater.  Unknown types
+            are provided as None.
+
+    Returns:
+        List[google.cloud.bigquery.query._AbstractQueryParameter]:
+            A list of query parameters.
+    """
+    if parameters is None:
+        return []
+
+    if isinstance(parameters, collections_abc.Mapping):
+        return to_query_parameters_dict(parameters, parameter_types)
+    else:
+        return to_query_parameters_list(parameters, parameter_types)
+
+
+def bigquery_scalar_type(value):
+    """Return a BigQuery name of the scalar type that matches the given value.
+
+    If the scalar type name could not be determined (e.g. for non-scalar
+    values), ``None`` is returned.
+
+    Args:
+        value (Any)
+
+    Returns:
+        Optional[str]: The BigQuery scalar type name.
+    """
+    if isinstance(value, bool):
+        return "BOOL"
+    elif isinstance(value, numbers.Integral):
+        return "INT64"
+    elif isinstance(value, numbers.Real):
+        return "FLOAT64"
+    elif isinstance(value, decimal.Decimal):
+        vtuple = value.as_tuple()
+        # NUMERIC values have precision of 38 (number of digits) and scale of 9 (number
+        # of fractional digits), and their max absolute value must be strictly smaller
+        # than 1.0E+29.
+        # https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#decimal_types
+        if (
+            len(vtuple.digits) <= 38  # max precision: 38
+            and vtuple.exponent >= -9  # max scale: 9
+            and _NUMERIC_SERVER_MIN <= value <= _NUMERIC_SERVER_MAX
+        ):
+            return "NUMERIC"
+        else:
+            return "BIGNUMERIC"
+
+    elif isinstance(value, str):
+        return "STRING"
+    elif isinstance(value, bytes):
+        return "BYTES"
+    elif isinstance(value, datetime.datetime):
+        return "DATETIME" if value.tzinfo is None else "TIMESTAMP"
+    elif isinstance(value, datetime.date):
+        return "DATE"
+    elif isinstance(value, datetime.time):
+        return "TIME"
+
+    return None
+
+
+def array_like(value):
+    """Determine if the given value is array-like.
+
+    Examples of array-like values (as interpreted by this function) are
+    sequences such as ``list`` and ``tuple``, but not strings and other
+    iterables such as sets.
+
+    Args:
+        value (Any)
+
+    Returns:
+        bool: ``True`` if the value is considered array-like, ``False`` otherwise.
+    """
+    return isinstance(value, collections_abc.Sequence) and not isinstance(
+        value, (str, bytes, bytearray)
+    )
+
+
+def to_bq_table_rows(rows_iterable):
+    """Convert table rows to BigQuery table Row instances.
+
+    Args:
+        rows_iterable (Iterable[Mapping]):
+            An iterable of row data items to convert to ``Row`` instances.
+
+    Returns:
+        Iterable[google.cloud.bigquery.table.Row]
+    """
+
+    def to_table_row(row):
+        # NOTE: We fetch ARROW values, thus we need to convert them to Python
+        # objects with as_py().
+        values = tuple(value.as_py() for value in row.values())
+        keys_to_index = {key: i for i, key in enumerate(row.keys())}
+        return table.Row(values, keys_to_index)
+
+    return (to_table_row(row_data) for row_data in rows_iterable)
+
+
+def raise_on_closed(
+    exc_msg, exc_class=exceptions.ProgrammingError, closed_attr_name="_closed"
+):
+    """Make public instance methods raise an error if the instance is closed."""
+
+    def _raise_on_closed(method):
+        """Make a non-static method raise an error if its containing instance is closed."""
+
+        def with_closed_check(self, *args, **kwargs):
+            if getattr(self, closed_attr_name):
+                raise exc_class(exc_msg)
+            return method(self, *args, **kwargs)
+
+        functools.update_wrapper(with_closed_check, method)
+        return with_closed_check
+
+    def decorate_public_methods(klass):
+        """Apply ``_raise_on_closed()`` decorator to public instance methods."""
+        for name in dir(klass):
+            if name.startswith("_") and name != "__iter__":
+                continue
+
+            member = getattr(klass, name)
+            if not callable(member):
+                continue
+
+            # We need to check for class/static methods directly in the instance
+            # __dict__, not via the retrieved attribute (`member`), as the
+            # latter is already a callable *produced* by one of these descriptors.
+            if isinstance(klass.__dict__[name], (staticmethod, classmethod)):
+                continue
+
+            member = _raise_on_closed(member)
+            setattr(klass, name, member)
+
+        return klass
+
+    return decorate_public_methods

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/dbapi/connection.py

@@ -0,0 +1,128 @@
+# Copyright 2017 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.
+
+"""Connection for the Google BigQuery DB-API."""
+
+import weakref
+
+from google.cloud import bigquery
+from google.cloud.bigquery.dbapi import cursor
+from google.cloud.bigquery.dbapi import _helpers
+
+
+@_helpers.raise_on_closed("Operating on a closed connection.")
+class Connection(object):
+    """DB-API Connection to Google BigQuery.
+
+    Args:
+        client (Optional[google.cloud.bigquery.Client]):
+            A REST API client used to connect to BigQuery. If not passed, a
+            client is created using default options inferred from the environment.
+        bqstorage_client(\
+            Optional[google.cloud.bigquery_storage_v1.BigQueryReadClient] \
+        ):
+            A client that uses the faster BigQuery Storage API to fetch rows from
+            BigQuery. If not passed, it is created using the same credentials
+            as ``client`` (provided that BigQuery Storage dependencies are installed).
+        prefer_bqstorage_client (Optional[bool]):
+            Prefer the BigQuery Storage client over the REST client. If Storage
+            client isn't available, fall back to the REST client. Defaults to
+            ``True``.
+    """
+
+    def __init__(
+        self,
+        client=None,
+        bqstorage_client=None,
+        prefer_bqstorage_client=True,
+    ):
+        if client is None:
+            client = bigquery.Client()
+            self._owns_client = True
+        else:
+            self._owns_client = False
+
+        # A warning is already raised by the BQ Storage client factory factory if
+        # instantiation fails, or if the given BQ Storage client instance is outdated.
+        if not prefer_bqstorage_client:
+            bqstorage_client = None
+            self._owns_bqstorage_client = False
+        elif bqstorage_client is None:
+            bqstorage_client = client._ensure_bqstorage_client()
+            self._owns_bqstorage_client = bqstorage_client is not None
+        else:
+            self._owns_bqstorage_client = False
+            bqstorage_client = client._ensure_bqstorage_client(bqstorage_client)
+
+        self._client = client
+        self._bqstorage_client = bqstorage_client
+
+        self._closed = False
+        self._cursors_created = weakref.WeakSet()
+
+    def close(self):
+        """Close the connection and any cursors created from it.
+
+        Any BigQuery clients explicitly passed to the constructor are *not*
+        closed, only those created by the connection instance itself.
+        """
+        self._closed = True
+
+        if self._owns_client:
+            self._client.close()
+
+        if self._owns_bqstorage_client:
+            # There is no close() on the BQ Storage client itself.
+            self._bqstorage_client._transport.grpc_channel.close()
+
+        for cursor_ in self._cursors_created:
+            if not cursor_._closed:
+                cursor_.close()
+
+    def commit(self):
+        """No-op, but for consistency raise an error if connection is closed."""
+
+    def cursor(self):
+        """Return a new cursor object.
+
+        Returns:
+            google.cloud.bigquery.dbapi.Cursor: A DB-API cursor that uses this connection.
+        """
+        new_cursor = cursor.Cursor(self)
+        self._cursors_created.add(new_cursor)
+        return new_cursor
+
+
+def connect(client=None, bqstorage_client=None, prefer_bqstorage_client=True):
+    """Construct a DB-API connection to Google BigQuery.
+
+    Args:
+        client (Optional[google.cloud.bigquery.Client]):
+            A REST API client used to connect to BigQuery. If not passed, a
+            client is created using default options inferred from the environment.
+        bqstorage_client(\
+            Optional[google.cloud.bigquery_storage_v1.BigQueryReadClient] \
+        ):
+            A client that uses the faster BigQuery Storage API to fetch rows from
+            BigQuery. If not passed, it is created using the same credentials
+            as ``client`` (provided that BigQuery Storage dependencies are installed).
+        prefer_bqstorage_client (Optional[bool]):
+            Prefer the BigQuery Storage client over the REST client. If Storage
+            client isn't available, fall back to the REST client. Defaults to
+            ``True``.
+
+    Returns:
+        google.cloud.bigquery.dbapi.Connection: A new DB-API connection to BigQuery.
+    """
+    return Connection(client, bqstorage_client, prefer_bqstorage_client)

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/dbapi/cursor.py

@@ -0,0 +1,589 @@
+# Copyright 2017 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.
+
+"""Cursor for the Google BigQuery DB-API."""
+
+from __future__ import annotations
+
+import collections
+from collections import abc as collections_abc
+import re
+from typing import Optional
+
+try:
+    from google.cloud.bigquery_storage import ArrowSerializationOptions
+except ImportError:
+    _ARROW_COMPRESSION_SUPPORT = False
+else:
+    # Having BQ Storage available implies that pyarrow >=1.0.0 is available, too.
+    _ARROW_COMPRESSION_SUPPORT = True
+
+from google.cloud.bigquery import job
+from google.cloud.bigquery.dbapi import _helpers
+from google.cloud.bigquery.dbapi import exceptions
+import google.cloud.exceptions  # type: ignore
+
+
+# Per PEP 249: A 7-item sequence containing information describing one result
+# column. The first two items (name and type_code) are mandatory, the other
+# five are optional and are set to None if no meaningful values can be
+# provided.
+Column = collections.namedtuple(
+    "Column",
+    [
+        "name",
+        "type_code",
+        "display_size",
+        "internal_size",
+        "precision",
+        "scale",
+        "null_ok",
+    ],
+)
+
+
+@_helpers.raise_on_closed("Operating on a closed cursor.")
+class Cursor(object):
+    """DB-API Cursor to Google BigQuery.
+
+    Args:
+        connection (google.cloud.bigquery.dbapi.Connection):
+            A DB-API connection to Google BigQuery.
+    """
+
+    def __init__(self, connection):
+        self.connection = connection
+        self.description = None
+        # Per PEP 249: The attribute is -1 in case no .execute*() has been
+        # performed on the cursor or the rowcount of the last operation
+        # cannot be determined by the interface.
+        self.rowcount = -1
+        # Per PEP 249: The arraysize attribute defaults to 1, meaning to fetch
+        # a single row at a time. However, we deviate from that, and set the
+        # default to None, allowing the backend to automatically determine the
+        # most appropriate size.
+        self.arraysize = None
+        self._query_data = None
+        self._query_rows = None
+        self._closed = False
+
+    @property
+    def query_job(self) -> Optional[job.QueryJob]:
+        """google.cloud.bigquery.job.query.QueryJob | None: The query job
+        created by the last ``execute*()`` call, if a query job was created.
+
+        .. note::
+            If the last ``execute*()`` call was ``executemany()``, this is the
+            last job created by ``executemany()``."""
+        rows = self._query_rows
+
+        if rows is None:
+            return None
+
+        job_id = rows.job_id
+        project = rows.project
+        location = rows.location
+        client = self.connection._client
+
+        if job_id is None:
+            return None
+
+        return client.get_job(job_id, location=location, project=project)
+
+    def close(self):
+        """Mark the cursor as closed, preventing its further use."""
+        self._closed = True
+
+    def _set_description(self, schema):
+        """Set description from schema.
+
+        Args:
+            schema (Sequence[google.cloud.bigquery.schema.SchemaField]):
+                A description of fields in the schema.
+        """
+        if schema is None:
+            self.description = None
+            return
+
+        self.description = tuple(
+            Column(
+                name=field.name,
+                type_code=field.field_type,
+                display_size=None,
+                internal_size=None,
+                precision=None,
+                scale=None,
+                null_ok=field.is_nullable,
+            )
+            for field in schema
+        )
+
+    def _set_rowcount(self, rows):
+        """Set the rowcount from a RowIterator.
+
+        Normally, this sets rowcount to the number of rows returned by the
+        query, but if it was a DML statement, it sets rowcount to the number
+        of modified rows.
+
+        Args:
+            query_results (google.cloud.bigquery.query._QueryResults):
+                Results of a query.
+        """
+        total_rows = 0
+        num_dml_affected_rows = rows.num_dml_affected_rows
+
+        if rows.total_rows is not None and rows.total_rows > 0:
+            total_rows = rows.total_rows
+        if num_dml_affected_rows is not None and num_dml_affected_rows > 0:
+            total_rows = num_dml_affected_rows
+        self.rowcount = total_rows
+
+    def execute(self, operation, parameters=None, job_id=None, job_config=None):
+        """Prepare and execute a database operation.
+
+        .. note::
+            When setting query parameters, values which are "text"
+            (``unicode`` in Python2, ``str`` in Python3) will use
+            the 'STRING' BigQuery type. Values which are "bytes" (``str`` in
+            Python2, ``bytes`` in Python3), will use using the 'BYTES' type.
+
+            A `~datetime.datetime` parameter without timezone information uses
+            the 'DATETIME' BigQuery type (example: Global Pi Day Celebration
+            March 14, 2017 at 1:59pm). A `~datetime.datetime` parameter with
+            timezone information uses the 'TIMESTAMP' BigQuery type (example:
+            a wedding on April 29, 2011 at 11am, British Summer Time).
+
+            For more information about BigQuery data types, see:
+            https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types
+
+            ``STRUCT``/``RECORD`` and ``REPEATED`` query parameters are not
+            yet supported. See:
+            https://github.com/GoogleCloudPlatform/google-cloud-python/issues/3524
+
+        Args:
+            operation (str): A Google BigQuery query string.
+
+            parameters (Union[Mapping[str, Any], Sequence[Any]]):
+                (Optional) dictionary or sequence of parameter values.
+
+            job_id (str | None):
+                (Optional and discouraged) The job ID to use when creating
+                the query job. For best performance and reliability, manually
+                setting a job ID is discouraged.
+
+            job_config (google.cloud.bigquery.job.QueryJobConfig):
+                (Optional) Extra configuration options for the query job.
+        """
+        formatted_operation, parameter_types = _format_operation(operation, parameters)
+        self._execute(
+            formatted_operation, parameters, job_id, job_config, parameter_types
+        )
+
+    def _execute(
+        self, formatted_operation, parameters, job_id, job_config, parameter_types
+    ):
+        self._query_data = None
+        self._query_results = None
+        client = self.connection._client
+
+        # The DB-API uses the pyformat formatting, since the way BigQuery does
+        # query parameters was not one of the standard options. Convert both
+        # the query and the parameters to the format expected by the client
+        # libraries.
+        query_parameters = _helpers.to_query_parameters(parameters, parameter_types)
+
+        config = job_config or job.QueryJobConfig()
+        config.query_parameters = query_parameters
+
+        # Start the query and wait for the query to finish.
+        try:
+            if job_id is not None:
+                rows = client.query(
+                    formatted_operation,
+                    job_config=job_config,
+                    job_id=job_id,
+                    job_retry=None,
+                ).result(
+                    page_size=self.arraysize,
+                )
+            else:
+                rows = client.query_and_wait(
+                    formatted_operation,
+                    job_config=config,
+                    page_size=self.arraysize,
+                )
+        except google.cloud.exceptions.GoogleCloudError as exc:
+            raise exceptions.DatabaseError(exc)
+
+        self._query_rows = rows
+        self._set_description(rows.schema)
+
+        if config.dry_run:
+            self.rowcount = 0
+        else:
+            self._set_rowcount(rows)
+
+    def executemany(self, operation, seq_of_parameters):
+        """Prepare and execute a database operation multiple times.
+
+        Args:
+            operation (str): A Google BigQuery query string.
+
+            seq_of_parameters (Union[Sequence[Mapping[str, Any], Sequence[Any]]]):
+                Sequence of many sets of parameter values.
+        """
+        if seq_of_parameters:
+            rowcount = 0
+            # There's no reason to format the line more than once, as
+            # the operation only barely depends on the parameters.  So
+            # we just use the first set of parameters. If there are
+            # different numbers or types of parameters, we'll error
+            # anyway.
+            formatted_operation, parameter_types = _format_operation(
+                operation, seq_of_parameters[0]
+            )
+            for parameters in seq_of_parameters:
+                self._execute(
+                    formatted_operation, parameters, None, None, parameter_types
+                )
+                rowcount += self.rowcount
+
+            self.rowcount = rowcount
+
+    def _try_fetch(self, size=None):
+        """Try to start fetching data, if not yet started.
+
+        Mutates self to indicate that iteration has started.
+        """
+        if self._query_data is not None:
+            # Already started fetching the data.
+            return
+
+        rows = self._query_rows
+        if rows is None:
+            raise exceptions.InterfaceError(
+                "No query results: execute() must be called before fetch."
+            )
+
+        bqstorage_client = self.connection._bqstorage_client
+        if rows._should_use_bqstorage(
+            bqstorage_client,
+            create_bqstorage_client=False,
+        ):
+            rows_iterable = self._bqstorage_fetch(bqstorage_client)
+            self._query_data = _helpers.to_bq_table_rows(rows_iterable)
+            return
+
+        self._query_data = iter(rows)
+
+    def _bqstorage_fetch(self, bqstorage_client):
+        """Start fetching data with the BigQuery Storage API.
+
+        The method assumes that the data about the relevant query job already
+        exists internally.
+
+        Args:
+            bqstorage_client(\
+                google.cloud.bigquery_storage_v1.BigQueryReadClient \
+            ):
+                A client tha know how to talk to the BigQuery Storage API.
+
+        Returns:
+            Iterable[Mapping]:
+                A sequence of rows, represented as dictionaries.
+        """
+        # Hitting this code path with a BQ Storage client instance implies that
+        # bigquery_storage can indeed be imported here without errors.
+        from google.cloud import bigquery_storage
+
+        table_reference = self._query_rows._table
+
+        requested_session = bigquery_storage.types.ReadSession(
+            table=table_reference.to_bqstorage(),
+            data_format=bigquery_storage.types.DataFormat.ARROW,
+        )
+
+        if _ARROW_COMPRESSION_SUPPORT:
+            requested_session.read_options.arrow_serialization_options.buffer_compression = (
+                ArrowSerializationOptions.CompressionCodec.LZ4_FRAME
+            )
+
+        read_session = bqstorage_client.create_read_session(
+            parent="projects/{}".format(table_reference.project),
+            read_session=requested_session,
+            # a single stream only, as DB API is not well-suited for multithreading
+            max_stream_count=1,
+            retry=None,
+            timeout=None,
+        )
+
+        if not read_session.streams:
+            return iter([])  # empty table, nothing to read
+
+        stream_name = read_session.streams[0].name
+        read_rows_stream = bqstorage_client.read_rows(stream_name)
+
+        rows_iterable = read_rows_stream.rows(read_session)
+        return rows_iterable
+
+    def fetchone(self):
+        """Fetch a single row from the results of the last ``execute*()`` call.
+
+        .. note::
+            If a dry run query was executed, no rows are returned.
+
+        Returns:
+            Tuple:
+                A tuple representing a row or ``None`` if no more data is
+                available.
+
+        Raises:
+            google.cloud.bigquery.dbapi.InterfaceError: if called before ``execute()``.
+        """
+        self._try_fetch()
+        try:
+            return next(self._query_data)
+        except StopIteration:
+            return None
+
+    def fetchmany(self, size=None):
+        """Fetch multiple results from the last ``execute*()`` call.
+
+        .. note::
+            If a dry run query was executed, no rows are returned.
+
+        .. note::
+            The size parameter is not used for the request/response size.
+            Set the ``arraysize`` attribute before calling ``execute()`` to
+            set the batch size.
+
+        Args:
+            size (int):
+                (Optional) Maximum number of rows to return. Defaults to the
+                ``arraysize`` property value. If ``arraysize`` is not set, it
+                defaults to ``1``.
+
+        Returns:
+            List[Tuple]: A list of rows.
+
+        Raises:
+            google.cloud.bigquery.dbapi.InterfaceError: if called before ``execute()``.
+        """
+        if size is None:
+            # Since self.arraysize can be None (a deviation from PEP 249),
+            # use an actual PEP 249 default of 1 in such case (*some* number
+            # is needed here).
+            size = self.arraysize if self.arraysize else 1
+
+        self._try_fetch(size=size)
+        rows = []
+
+        for row in self._query_data:
+            rows.append(row)
+            if len(rows) >= size:
+                break
+
+        return rows
+
+    def fetchall(self):
+        """Fetch all remaining results from the last ``execute*()`` call.
+
+        .. note::
+            If a dry run query was executed, no rows are returned.
+
+        Returns:
+            List[Tuple]: A list of all the rows in the results.
+
+        Raises:
+            google.cloud.bigquery.dbapi.InterfaceError: if called before ``execute()``.
+        """
+        self._try_fetch()
+        return list(self._query_data)
+
+    def setinputsizes(self, sizes):
+        """No-op, but for consistency raise an error if cursor is closed."""
+
+    def setoutputsize(self, size, column=None):
+        """No-op, but for consistency raise an error if cursor is closed."""
+
+    def __iter__(self):
+        self._try_fetch()
+        return iter(self._query_data)
+
+
+def _format_operation_list(operation, parameters):
+    """Formats parameters in operation in the way BigQuery expects.
+
+    The input operation will be a query like ``SELECT %s`` and the output
+    will be a query like ``SELECT ?``.
+
+    Args:
+        operation (str): A Google BigQuery query string.
+
+        parameters (Sequence[Any]): Sequence of parameter values.
+
+    Returns:
+        str: A formatted query string.
+
+    Raises:
+        google.cloud.bigquery.dbapi.ProgrammingError:
+            if a parameter used in the operation is not found in the
+            ``parameters`` argument.
+    """
+    formatted_params = ["?" for _ in parameters]
+
+    try:
+        return operation % tuple(formatted_params)
+    except (TypeError, ValueError) as exc:
+        raise exceptions.ProgrammingError(exc)
+
+
+def _format_operation_dict(operation, parameters):
+    """Formats parameters in operation in the way BigQuery expects.
+
+    The input operation will be a query like ``SELECT %(namedparam)s`` and
+    the output will be a query like ``SELECT @namedparam``.
+
+    Args:
+        operation (str): A Google BigQuery query string.
+
+        parameters (Mapping[str, Any]): Dictionary of parameter values.
+
+    Returns:
+        str: A formatted query string.
+
+    Raises:
+        google.cloud.bigquery.dbapi.ProgrammingError:
+            if a parameter used in the operation is not found in the
+            ``parameters`` argument.
+    """
+    formatted_params = {}
+    for name in parameters:
+        escaped_name = name.replace("`", r"\`")
+        formatted_params[name] = "@`{}`".format(escaped_name)
+
+    try:
+        return operation % formatted_params
+    except (KeyError, ValueError, TypeError) as exc:
+        raise exceptions.ProgrammingError(exc)
+
+
+def _format_operation(operation, parameters):
+    """Formats parameters in operation in way BigQuery expects.
+
+    Args:
+        operation (str): A Google BigQuery query string.
+
+        parameters (Union[Mapping[str, Any], Sequence[Any]]):
+            Optional parameter values.
+
+    Returns:
+        str: A formatted query string.
+
+    Raises:
+        google.cloud.bigquery.dbapi.ProgrammingError:
+            if a parameter used in the operation is not found in the
+            ``parameters`` argument.
+    """
+    if parameters is None or len(parameters) == 0:
+        return operation.replace("%%", "%"), None  # Still do percent de-escaping.
+
+    operation, parameter_types = _extract_types(operation)
+    if parameter_types is None:
+        raise exceptions.ProgrammingError(
+            f"Parameters were provided, but {repr(operation)} has no placeholders."
+        )
+
+    if isinstance(parameters, collections_abc.Mapping):
+        return _format_operation_dict(operation, parameters), parameter_types
+
+    return _format_operation_list(operation, parameters), parameter_types
+
+
+def _extract_types(
+    operation,
+    extra_type_sub=re.compile(
+        r"""
+        (%*)          # Extra %s.  We'll deal with these in the replacement code
+
+        %             # Beginning of replacement, %s, %(...)s
+
+        (?:\(         # Begin of optional name and/or type
+        ([^:)]*)      # name
+        (?::          # ':' introduces type
+          (             # start of type group
+            [a-zA-Z0-9_<>, ]+ # First part, no parens
+
+            (?:               # start sets of parens + non-paren text
+              \([0-9 ,]+\)      # comma-separated groups of digits in parens
+                                # (e.g. string(10))
+              (?=[, >)])        # Must be followed by ,>) or space
+              [a-zA-Z0-9<>, ]*  # Optional non-paren chars
+            )*                # Can be zero or more of parens and following text
+          )             # end of type group
+        )?            # close type clause ":type"
+        \))?          # End of optional name and/or type
+
+        s             # End of replacement
+        """,
+        re.VERBOSE,
+    ).sub,
+):
+    """Remove type information from parameter placeholders.
+
+    For every parameter of the form %(name:type)s, replace with %(name)s and add the
+    item name->type to dict that's returned.
+
+    Returns operation without type information and a dictionary of names and types.
+    """
+    parameter_types = None
+
+    def repl(m):
+        nonlocal parameter_types
+        prefix, name, type_ = m.groups()
+        if len(prefix) % 2:
+            # The prefix has an odd number of %s, the last of which
+            # escapes the % we're looking for, so we don't want to
+            # change anything.
+            return m.group(0)
+
+        try:
+            if name:
+                if not parameter_types:
+                    parameter_types = {}
+                if type_:
+                    if name in parameter_types:
+                        if type_ != parameter_types[name]:
+                            raise exceptions.ProgrammingError(
+                                f"Conflicting types for {name}: "
+                                f"{parameter_types[name]} and {type_}."
+                            )
+                    else:
+                        parameter_types[name] = type_
+                else:
+                    if not isinstance(parameter_types, dict):
+                        raise TypeError()
+
+                return f"{prefix}%({name})s"
+            else:
+                if parameter_types is None:
+                    parameter_types = []
+                parameter_types.append(type_)
+                return f"{prefix}%s"
+        except (AttributeError, TypeError):
+            raise exceptions.ProgrammingError(
+                f"{repr(operation)} mixes named and unamed parameters."
+            )
+
+    return extra_type_sub(repl, operation), parameter_types

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/dbapi/exceptions.py

@@ -0,0 +1,58 @@
+# Copyright 2017 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.
+
+"""Exceptions used in the Google BigQuery DB-API."""
+
+
+class Warning(Exception):
+    """Exception raised for important DB-API warnings."""
+
+
+class Error(Exception):
+    """Exception representing all non-warning DB-API errors."""
+
+
+class InterfaceError(Error):
+    """DB-API error related to the database interface."""
+
+
+class DatabaseError(Error):
+    """DB-API error related to the database."""
+
+
+class DataError(DatabaseError):
+    """DB-API error due to problems with the processed data."""
+
+
+class OperationalError(DatabaseError):
+    """DB-API error related to the database operation.
+
+    These errors are not necessarily under the control of the programmer.
+    """
+
+
+class IntegrityError(DatabaseError):
+    """DB-API error when integrity of the database is affected."""
+
+
+class InternalError(DatabaseError):
+    """DB-API error when the database encounters an internal error."""
+
+
+class ProgrammingError(DatabaseError):
+    """DB-API exception raised for programming errors."""
+
+
+class NotSupportedError(DatabaseError):
+    """DB-API error for operations not supported by the database or API."""

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/dbapi/types.py

@@ -0,0 +1,96 @@
+# Copyright 2017 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.
+
+"""Types used in the Google BigQuery DB-API.
+
+See `PEP-249`_ for details.
+
+.. _PEP-249:
+    https://www.python.org/dev/peps/pep-0249/#type-objects-and-constructors
+"""
+
+import datetime
+
+
+Date = datetime.date
+Time = datetime.time
+Timestamp = datetime.datetime
+DateFromTicks = datetime.date.fromtimestamp
+TimestampFromTicks = datetime.datetime.fromtimestamp
+
+
+def Binary(data):
+    """Contruct a DB-API binary value.
+
+    Args:
+        data (bytes-like): An object containing binary data and that
+                           can be converted to bytes with the `bytes` builtin.
+
+    Returns:
+        bytes: The binary data as a bytes object.
+    """
+    if isinstance(data, int):
+        # This is not the conversion we're looking for, because it
+        # will simply create a bytes object of the given size.
+        raise TypeError("cannot convert `int` object to binary")
+
+    try:
+        return bytes(data)
+    except TypeError:
+        if isinstance(data, str):
+            return data.encode("utf-8")
+        else:
+            raise
+
+
+def TimeFromTicks(ticks, tz=None):
+    """Construct a DB-API time value from the given ticks value.
+
+    Args:
+        ticks (float):
+            a number of seconds since the epoch; see the documentation of the
+            standard Python time module for details.
+
+        tz (datetime.tzinfo): (Optional) time zone to use for conversion
+
+    Returns:
+        datetime.time: time represented by ticks.
+    """
+    dt = datetime.datetime.fromtimestamp(ticks, tz=tz)
+    return dt.timetz()
+
+
+class _DBAPITypeObject(object):
+    """DB-API type object which compares equal to many different strings.
+
+    See `PEP-249`_ for details.
+
+    .. _PEP-249:
+        https://www.python.org/dev/peps/pep-0249/#implementation-hints-for-module-authors
+    """
+
+    def __init__(self, *values):
+        self.values = values
+
+    def __eq__(self, other):
+        return other in self.values
+
+
+STRING = "STRING"
+BINARY = _DBAPITypeObject("BYTES", "RECORD", "STRUCT")
+NUMBER = _DBAPITypeObject(
+    "INTEGER", "INT64", "FLOAT", "FLOAT64", "NUMERIC", "BIGNUMERIC", "BOOLEAN", "BOOL"
+)
+DATETIME = _DBAPITypeObject("TIMESTAMP", "DATE", "TIME", "DATETIME")
+ROWID = "ROWID"

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/job/__init__.py

@@ -0,0 +1,89 @@
+# Copyright 2015 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.
+
+"""Define API Jobs."""
+
+from google.cloud.bigquery.job.base import _AsyncJob
+from google.cloud.bigquery.job.base import _error_result_to_exception
+from google.cloud.bigquery.job.base import _DONE_STATE
+from google.cloud.bigquery.job.base import _JobConfig
+from google.cloud.bigquery.job.base import _JobReference
+from google.cloud.bigquery.job.base import ReservationUsage
+from google.cloud.bigquery.job.base import ScriptStatistics
+from google.cloud.bigquery.job.base import ScriptStackFrame
+from google.cloud.bigquery.job.base import TransactionInfo
+from google.cloud.bigquery.job.base import UnknownJob
+from google.cloud.bigquery.job.copy_ import CopyJob
+from google.cloud.bigquery.job.copy_ import CopyJobConfig
+from google.cloud.bigquery.job.copy_ import OperationType
+from google.cloud.bigquery.job.extract import ExtractJob
+from google.cloud.bigquery.job.extract import ExtractJobConfig
+from google.cloud.bigquery.job.load import LoadJob
+from google.cloud.bigquery.job.load import LoadJobConfig
+from google.cloud.bigquery.job.query import _contains_order_by
+from google.cloud.bigquery.job.query import DmlStats
+from google.cloud.bigquery.job.query import QueryJob
+from google.cloud.bigquery.job.query import QueryJobConfig
+from google.cloud.bigquery.job.query import QueryPlanEntry
+from google.cloud.bigquery.job.query import QueryPlanEntryStep
+from google.cloud.bigquery.job.query import ScriptOptions
+from google.cloud.bigquery.job.query import TimelineEntry
+from google.cloud.bigquery.job.query import IncrementalResultStats
+from google.cloud.bigquery.enums import Compression
+from google.cloud.bigquery.enums import CreateDisposition
+from google.cloud.bigquery.enums import DestinationFormat
+from google.cloud.bigquery.enums import Encoding
+from google.cloud.bigquery.enums import QueryPriority
+from google.cloud.bigquery.enums import SchemaUpdateOption
+from google.cloud.bigquery.enums import SourceFormat
+from google.cloud.bigquery.enums import WriteDisposition
+
+
+# Include classes previously in job.py for backwards compatibility.
+__all__ = [
+    "_AsyncJob",
+    "_error_result_to_exception",
+    "_DONE_STATE",
+    "_JobConfig",
+    "_JobReference",
+    "ReservationUsage",
+    "ScriptStatistics",
+    "ScriptStackFrame",
+    "UnknownJob",
+    "CopyJob",
+    "CopyJobConfig",
+    "OperationType",
+    "ExtractJob",
+    "ExtractJobConfig",
+    "LoadJob",
+    "LoadJobConfig",
+    "_contains_order_by",
+    "DmlStats",
+    "QueryJob",
+    "QueryJobConfig",
+    "QueryPlanEntry",
+    "QueryPlanEntryStep",
+    "ScriptOptions",
+    "TimelineEntry",
+    "Compression",
+    "CreateDisposition",
+    "DestinationFormat",
+    "Encoding",
+    "QueryPriority",
+    "SchemaUpdateOption",
+    "SourceFormat",
+    "TransactionInfo",
+    "WriteDisposition",
+    "IncrementalResultStats",
+]

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/job/base.py

@@ -0,0 +1,1192 @@
+# Copyright 2015 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.
+
+"""Base classes and helpers for job classes."""
+
+from collections import namedtuple
+import copy
+import http
+import threading
+import typing
+from typing import ClassVar, Dict, Optional, Sequence
+
+from google.api_core import retry as retries
+from google.api_core import exceptions
+import google.api_core.future.polling
+
+from google.cloud.bigquery import _helpers
+from google.cloud.bigquery._helpers import _int_or_none
+from google.cloud.bigquery.retry import (
+    DEFAULT_GET_JOB_TIMEOUT,
+    DEFAULT_RETRY,
+)
+
+
+_DONE_STATE = "DONE"
+_STOPPED_REASON = "stopped"
+_ERROR_REASON_TO_EXCEPTION = {
+    "accessDenied": http.client.FORBIDDEN,
+    "backendError": http.client.INTERNAL_SERVER_ERROR,
+    "billingNotEnabled": http.client.FORBIDDEN,
+    "billingTierLimitExceeded": http.client.BAD_REQUEST,
+    "blocked": http.client.FORBIDDEN,
+    "duplicate": http.client.CONFLICT,
+    "internalError": http.client.INTERNAL_SERVER_ERROR,
+    "invalid": http.client.BAD_REQUEST,
+    "invalidQuery": http.client.BAD_REQUEST,
+    "notFound": http.client.NOT_FOUND,
+    "notImplemented": http.client.NOT_IMPLEMENTED,
+    "policyViolation": http.client.FORBIDDEN,
+    "quotaExceeded": http.client.FORBIDDEN,
+    "rateLimitExceeded": http.client.TOO_MANY_REQUESTS,
+    "resourceInUse": http.client.BAD_REQUEST,
+    "resourcesExceeded": http.client.BAD_REQUEST,
+    "responseTooLarge": http.client.FORBIDDEN,
+    "stopped": http.client.OK,
+    "tableUnavailable": http.client.BAD_REQUEST,
+}
+
+
+def _error_result_to_exception(error_result, errors=None):
+    """Maps BigQuery error reasons to an exception.
+
+    The reasons and their matching HTTP status codes are documented on
+    the `troubleshooting errors`_ page.
+
+    .. _troubleshooting errors: https://cloud.google.com/bigquery\
+        /troubleshooting-errors
+
+    Args:
+        error_result (Mapping[str, str]): The error result from BigQuery.
+        errors (Union[Iterable[str], None]): The detailed error messages.
+
+    Returns:
+        google.cloud.exceptions.GoogleAPICallError: The mapped exception.
+    """
+    reason = error_result.get("reason")
+    status_code = _ERROR_REASON_TO_EXCEPTION.get(
+        reason, http.client.INTERNAL_SERVER_ERROR
+    )
+    # Manually create error message to preserve both error_result and errors.
+    # Can be removed once b/310544564 and b/318889899 are resolved.
+    concatenated_errors = ""
+    if errors:
+        concatenated_errors = "; "
+        for err in errors:
+            concatenated_errors += ", ".join(
+                [f"{key}: {value}" for key, value in err.items()]
+            )
+            concatenated_errors += "; "
+
+        # strips off the last unneeded semicolon and space
+        concatenated_errors = concatenated_errors[:-2]
+
+    error_message = error_result.get("message", "") + concatenated_errors
+
+    return exceptions.from_http_status(
+        status_code, error_message, errors=[error_result]
+    )
+
+
+ReservationUsage = namedtuple("ReservationUsage", "name slot_ms")
+ReservationUsage.__doc__ = "Job resource usage for a reservation."
+ReservationUsage.name.__doc__ = (
+    'Reservation name or "unreserved" for on-demand resources usage.'
+)
+ReservationUsage.slot_ms.__doc__ = (
+    "Total slot milliseconds used by the reservation for a particular job."
+)
+
+
+class TransactionInfo(typing.NamedTuple):
+    """[Alpha] Information of a multi-statement transaction.
+
+    https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#TransactionInfo
+
+    .. versionadded:: 2.24.0
+    """
+
+    transaction_id: str
+    """Output only. ID of the transaction."""
+
+    @classmethod
+    def from_api_repr(cls, transaction_info: Dict[str, str]) -> "TransactionInfo":
+        return cls(transaction_info["transactionId"])
+
+
+class _JobReference(object):
+    """A reference to a job.
+
+    Args:
+        job_id (str): ID of the job to run.
+        project (str): ID of the project where the job runs.
+        location (str): Location of where the job runs.
+    """
+
+    def __init__(self, job_id, project, location):
+        self._properties = {"jobId": job_id, "projectId": project}
+        # The location field must not be populated if it is None.
+        if location:
+            self._properties["location"] = location
+
+    @property
+    def job_id(self):
+        """str: ID of the job."""
+        return self._properties.get("jobId")
+
+    @property
+    def project(self):
+        """str: ID of the project where the job runs."""
+        return self._properties.get("projectId")
+
+    @property
+    def location(self):
+        """str: Location where the job runs."""
+        return self._properties.get("location")
+
+    def _to_api_repr(self):
+        """Returns the API resource representation of the job reference."""
+        return copy.deepcopy(self._properties)
+
+    @classmethod
+    def _from_api_repr(cls, resource):
+        """Returns a job reference for an API resource representation."""
+        job_id = resource.get("jobId")
+        project = resource.get("projectId")
+        location = resource.get("location")
+        job_ref = cls(job_id, project, location)
+        return job_ref
+
+
+class _JobConfig(object):
+    """Abstract base class for job configuration objects.
+
+    Args:
+        job_type (str): The key to use for the job configuration.
+    """
+
+    def __init__(self, job_type, **kwargs):
+        self._job_type = job_type
+        self._properties = {job_type: {}}
+        for prop, val in kwargs.items():
+            setattr(self, prop, val)
+
+    def __setattr__(self, name, value):
+        """Override to be able to raise error if an unknown property is being set"""
+        if not name.startswith("_") and not hasattr(type(self), name):
+            raise AttributeError(
+                "Property {} is unknown for {}.".format(name, type(self))
+            )
+        super(_JobConfig, self).__setattr__(name, value)
+
+    @property
+    def job_timeout_ms(self):
+        """Optional parameter. Job timeout in milliseconds. If this time limit is exceeded, BigQuery might attempt to stop the job.
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfiguration.FIELDS.job_timeout_ms
+        e.g.
+
+            job_config = bigquery.QueryJobConfig( job_timeout_ms = 5000 )
+            or
+            job_config.job_timeout_ms = 5000
+
+        Raises:
+            ValueError: If ``value`` type is invalid.
+        """
+
+        # None as this is an optional parameter.
+        if self._properties.get("jobTimeoutMs"):
+            return self._properties["jobTimeoutMs"]
+        return None
+
+    @job_timeout_ms.setter
+    def job_timeout_ms(self, value):
+        try:
+            value = _int_or_none(value)
+        except ValueError as err:
+            raise ValueError("Pass an int for jobTimeoutMs, e.g. 5000").with_traceback(
+                err.__traceback__
+            )
+
+        if value is not None:
+            # docs indicate a string is expected by the API
+            self._properties["jobTimeoutMs"] = str(value)
+        else:
+            self._properties.pop("jobTimeoutMs", None)
+
+    @property
+    def max_slots(self) -> Optional[int]:
+        """The maximum rate of slot consumption to allow for this job.
+
+        If set, the number of slots used to execute the job will be throttled
+        to try and keep its slot consumption below the requested rate.
+        This feature is not generally available.
+        """
+
+        max_slots = self._properties.get("maxSlots")
+        if max_slots is not None:
+            if isinstance(max_slots, str):
+                return int(max_slots)
+            if isinstance(max_slots, int):
+                return max_slots
+        return None
+
+    @max_slots.setter
+    def max_slots(self, value):
+        try:
+            value = _int_or_none(value)
+        except ValueError as err:
+            raise ValueError("Pass an int for max slots, e.g. 100").with_traceback(
+                err.__traceback__
+            )
+
+        if value is not None:
+            self._properties["maxSlots"] = str(value)
+        else:
+            self._properties.pop("maxSlots", None)
+
+    @property
+    def reservation(self):
+        """str: Optional. The reservation that job would use.
+
+        User can specify a reservation to execute the job. If reservation is
+        not set, reservation is determined based on the rules defined by the
+        reservation assignments. The expected format is
+        projects/{project}/locations/{location}/reservations/{reservation}.
+
+        Raises:
+            ValueError: If ``value`` type is not None or of string type.
+        """
+        return self._properties.setdefault("reservation", None)
+
+    @reservation.setter
+    def reservation(self, value):
+        if value and not isinstance(value, str):
+            raise ValueError("Reservation must be None or a string.")
+        self._properties["reservation"] = value
+
+    @property
+    def labels(self):
+        """Dict[str, str]: Labels for the job.
+
+        This method always returns a dict. Once a job has been created on the
+        server, its labels cannot be modified anymore.
+
+        Raises:
+            ValueError: If ``value`` type is invalid.
+        """
+        return self._properties.setdefault("labels", {})
+
+    @labels.setter
+    def labels(self, value):
+        if not isinstance(value, dict):
+            raise ValueError("Pass a dict")
+        self._properties["labels"] = value
+
+    def _get_sub_prop(self, key, default=None):
+        """Get a value in the ``self._properties[self._job_type]`` dictionary.
+
+        Most job properties are inside the dictionary related to the job type
+        (e.g. 'copy', 'extract', 'load', 'query'). Use this method to access
+        those properties::
+
+            self._get_sub_prop('destinationTable')
+
+        This is equivalent to using the ``_helpers._get_sub_prop`` function::
+
+            _helpers._get_sub_prop(
+                self._properties, ['query', 'destinationTable'])
+
+        Args:
+            key (str):
+                Key for the value to get in the
+                ``self._properties[self._job_type]`` dictionary.
+            default (Optional[object]):
+                Default value to return if the key is not found.
+                Defaults to :data:`None`.
+
+        Returns:
+            object: The value if present or the default.
+        """
+        return _helpers._get_sub_prop(
+            self._properties, [self._job_type, key], default=default
+        )
+
+    def _set_sub_prop(self, key, value):
+        """Set a value in the ``self._properties[self._job_type]`` dictionary.
+
+        Most job properties are inside the dictionary related to the job type
+        (e.g. 'copy', 'extract', 'load', 'query'). Use this method to set
+        those properties::
+
+            self._set_sub_prop('useLegacySql', False)
+
+        This is equivalent to using the ``_helper._set_sub_prop`` function::
+
+            _helper._set_sub_prop(
+                self._properties, ['query', 'useLegacySql'], False)
+
+        Args:
+            key (str):
+                Key to set in the ``self._properties[self._job_type]``
+                dictionary.
+            value (object): Value to set.
+        """
+        _helpers._set_sub_prop(self._properties, [self._job_type, key], value)
+
+    def _del_sub_prop(self, key):
+        """Remove ``key`` from the ``self._properties[self._job_type]`` dict.
+
+        Most job properties are inside the dictionary related to the job type
+        (e.g. 'copy', 'extract', 'load', 'query'). Use this method to clear
+        those properties::
+
+            self._del_sub_prop('useLegacySql')
+
+        This is equivalent to using the ``_helper._del_sub_prop`` function::
+
+            _helper._del_sub_prop(
+                self._properties, ['query', 'useLegacySql'])
+
+        Args:
+            key (str):
+                Key to remove in the ``self._properties[self._job_type]``
+                dictionary.
+        """
+        _helpers._del_sub_prop(self._properties, [self._job_type, key])
+
+    def to_api_repr(self) -> dict:
+        """Build an API representation of the job config.
+
+        Returns:
+            Dict: A dictionary in the format used by the BigQuery API.
+        """
+        return copy.deepcopy(self._properties)
+
+    def _fill_from_default(self, default_job_config=None):
+        """Merge this job config with a default job config.
+
+        The keys in this object take precedence over the keys in the default
+        config. The merge is done at the top-level as well as for keys one
+        level below the job type.
+
+        Args:
+            default_job_config (google.cloud.bigquery.job._JobConfig):
+                The default job config that will be used to fill in self.
+
+        Returns:
+            google.cloud.bigquery.job._JobConfig: A new (merged) job config.
+        """
+        if not default_job_config:
+            new_job_config = copy.deepcopy(self)
+            return new_job_config
+
+        if self._job_type != default_job_config._job_type:
+            raise TypeError(
+                "attempted to merge two incompatible job types: "
+                + repr(self._job_type)
+                + ", "
+                + repr(default_job_config._job_type)
+            )
+
+        # cls is one of the job config subclasses that provides the job_type argument to
+        # this base class on instantiation, thus missing-parameter warning is a false
+        # positive here.
+        new_job_config = self.__class__()  # pytype: disable=missing-parameter
+
+        default_job_properties = copy.deepcopy(default_job_config._properties)
+        for key in self._properties:
+            if key != self._job_type:
+                default_job_properties[key] = self._properties[key]
+
+        default_job_properties[self._job_type].update(self._properties[self._job_type])
+        new_job_config._properties = default_job_properties
+
+        return new_job_config
+
+    @classmethod
+    def from_api_repr(cls, resource: dict) -> "_JobConfig":
+        """Factory: construct a job configuration given its API representation
+
+        Args:
+            resource (Dict):
+                A job configuration in the same representation as is returned
+                from the API.
+
+        Returns:
+            google.cloud.bigquery.job._JobConfig: Configuration parsed from ``resource``.
+        """
+        # cls is one of the job config subclasses that provides the job_type argument to
+        # this base class on instantiation, thus missing-parameter warning is a false
+        # positive here.
+        job_config = cls()  # type: ignore  # pytype: disable=missing-parameter
+        job_config._properties = resource
+        return job_config
+
+
+class _AsyncJob(google.api_core.future.polling.PollingFuture):
+    """Base class for asynchronous jobs.
+
+    Args:
+        job_id (Union[str, _JobReference]):
+            Job's ID in the project associated with the client or a
+            fully-qualified job reference.
+        client (google.cloud.bigquery.client.Client):
+            Client which holds credentials and project configuration.
+    """
+
+    _JOB_TYPE = "unknown"
+    _CONFIG_CLASS: ClassVar
+
+    def __init__(self, job_id, client):
+        super(_AsyncJob, self).__init__()
+
+        # The job reference can be either a plain job ID or the full resource.
+        # Populate the properties dictionary consistently depending on what has
+        # been passed in.
+        job_ref = job_id
+        if not isinstance(job_id, _JobReference):
+            job_ref = _JobReference(job_id, client.project, None)
+        self._properties = {"jobReference": job_ref._to_api_repr()}
+
+        self._client = client
+        self._result_set = False
+        self._completion_lock = threading.Lock()
+
+    @property
+    def configuration(self) -> _JobConfig:
+        """Job-type specific configurtion."""
+        configuration: _JobConfig = self._CONFIG_CLASS()  # pytype: disable=not-callable
+        configuration._properties = self._properties.setdefault("configuration", {})
+        return configuration
+
+    @property
+    def job_id(self):
+        """str: ID of the job."""
+        return _helpers._get_sub_prop(self._properties, ["jobReference", "jobId"])
+
+    @property
+    def parent_job_id(self):
+        """Return the ID of the parent job.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatistics.FIELDS.parent_job_id
+
+        Returns:
+            Optional[str]: parent job id.
+        """
+        return _helpers._get_sub_prop(self._properties, ["statistics", "parentJobId"])
+
+    @property
+    def script_statistics(self) -> Optional["ScriptStatistics"]:
+        """Statistics for a child job of a script."""
+        resource = _helpers._get_sub_prop(
+            self._properties, ["statistics", "scriptStatistics"]
+        )
+        if resource is None:
+            return None
+        return ScriptStatistics(resource)
+
+    @property
+    def session_info(self) -> Optional["SessionInfo"]:
+        """[Preview] Information of the session if this job is part of one.
+
+        .. versionadded:: 2.29.0
+        """
+        resource = _helpers._get_sub_prop(
+            self._properties, ["statistics", "sessionInfo"]
+        )
+        if resource is None:
+            return None
+        return SessionInfo(resource)
+
+    @property
+    def num_child_jobs(self):
+        """The number of child jobs executed.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatistics.FIELDS.num_child_jobs
+
+        Returns:
+            int
+        """
+        count = _helpers._get_sub_prop(self._properties, ["statistics", "numChildJobs"])
+        return int(count) if count is not None else 0
+
+    @property
+    def project(self):
+        """Project bound to the job.
+
+        Returns:
+            str: the project (derived from the client).
+        """
+        return _helpers._get_sub_prop(self._properties, ["jobReference", "projectId"])
+
+    @property
+    def location(self):
+        """str: Location where the job runs."""
+        return _helpers._get_sub_prop(self._properties, ["jobReference", "location"])
+
+    @property
+    def reservation_id(self):
+        """str: Name of the primary reservation assigned to this job.
+
+        Note that this could be different than reservations reported in
+        the reservation field if parent reservations were used to execute
+        this job.
+        """
+        return _helpers._get_sub_prop(
+            self._properties, ["statistics", "reservation_id"]
+        )
+
+    def _require_client(self, client):
+        """Check client or verify over-ride.
+
+        Args:
+            client (Optional[google.cloud.bigquery.client.Client]):
+                the client to use.  If not passed, falls back to the
+                ``client`` stored on the current dataset.
+
+        Returns:
+            google.cloud.bigquery.client.Client:
+                The client passed in or the currently bound client.
+        """
+        if client is None:
+            client = self._client
+        return client
+
+    @property
+    def job_type(self):
+        """Type of job.
+
+        Returns:
+            str: one of 'load', 'copy', 'extract', 'query'.
+        """
+        return self._JOB_TYPE
+
+    @property
+    def path(self):
+        """URL path for the job's APIs.
+
+        Returns:
+            str: the path based on project and job ID.
+        """
+        return "/projects/%s/jobs/%s" % (self.project, self.job_id)
+
+    @property
+    def labels(self):
+        """Dict[str, str]: Labels for the job."""
+        return self._properties.setdefault("configuration", {}).setdefault("labels", {})
+
+    @property
+    def etag(self):
+        """ETag for the job resource.
+
+        Returns:
+            Optional[str]: the ETag (None until set from the server).
+        """
+        return self._properties.get("etag")
+
+    @property
+    def self_link(self):
+        """URL for the job resource.
+
+        Returns:
+            Optional[str]: the URL (None until set from the server).
+        """
+        return self._properties.get("selfLink")
+
+    @property
+    def user_email(self):
+        """E-mail address of user who submitted the job.
+
+        Returns:
+            Optional[str]: the URL (None until set from the server).
+        """
+        return self._properties.get("user_email")
+
+    @property
+    def created(self):
+        """Datetime at which the job was created.
+
+        Returns:
+            Optional[datetime.datetime]:
+                the creation time (None until set from the server).
+        """
+        millis = _helpers._get_sub_prop(
+            self._properties, ["statistics", "creationTime"]
+        )
+        if millis is not None:
+            return _helpers._datetime_from_microseconds(millis * 1000.0)
+
+    @property
+    def started(self):
+        """Datetime at which the job was started.
+
+        Returns:
+            Optional[datetime.datetime]:
+                the start time (None until set from the server).
+        """
+        millis = _helpers._get_sub_prop(self._properties, ["statistics", "startTime"])
+        if millis is not None:
+            return _helpers._datetime_from_microseconds(millis * 1000.0)
+
+    @property
+    def ended(self):
+        """Datetime at which the job finished.
+
+        Returns:
+            Optional[datetime.datetime]:
+                the end time (None until set from the server).
+        """
+        millis = _helpers._get_sub_prop(self._properties, ["statistics", "endTime"])
+        if millis is not None:
+            return _helpers._datetime_from_microseconds(millis * 1000.0)
+
+    def _job_statistics(self):
+        """Helper for job-type specific statistics-based properties."""
+        statistics = self._properties.get("statistics", {})
+        return statistics.get(self._JOB_TYPE, {})
+
+    @property
+    def reservation_usage(self):
+        """Job resource usage breakdown by reservation.
+
+        Returns:
+            List[google.cloud.bigquery.job.ReservationUsage]:
+                Reservation usage stats. Can be empty if not set from the server.
+        """
+        usage_stats_raw = _helpers._get_sub_prop(
+            self._properties, ["statistics", "reservationUsage"], default=()
+        )
+        return [
+            ReservationUsage(name=usage["name"], slot_ms=int(usage["slotMs"]))
+            for usage in usage_stats_raw
+        ]
+
+    @property
+    def transaction_info(self) -> Optional[TransactionInfo]:
+        """Information of the multi-statement transaction if this job is part of one.
+
+        Since a scripting query job can execute multiple transactions, this
+        property is only expected on child jobs. Use the
+        :meth:`google.cloud.bigquery.client.Client.list_jobs` method with the
+        ``parent_job`` parameter to iterate over child jobs.
+
+        .. versionadded:: 2.24.0
+        """
+        info = self._properties.get("statistics", {}).get("transactionInfo")
+        if info is None:
+            return None
+        else:
+            return TransactionInfo.from_api_repr(info)
+
+    @property
+    def error_result(self):
+        """Output only. Final error result of the job.
+
+        If present, indicates that the job has completed and was unsuccessful.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatus.FIELDS.error_result
+
+        Returns:
+            Optional[Mapping]: the error information (None until set from the server).
+        """
+        status = self._properties.get("status")
+        if status is not None:
+            return status.get("errorResult")
+
+    @property
+    def errors(self):
+        """Output only. The first errors encountered during the running of the job.
+
+        The final message includes the number of errors that caused the process to stop.
+        Errors here do not necessarily mean that the job has not completed or was unsuccessful.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatus.FIELDS.errors
+
+        Returns:
+            Optional[List[Mapping]]:
+                the error information (None until set from the server).
+        """
+        status = self._properties.get("status")
+        if status is not None:
+            return status.get("errors")
+
+    @property
+    def state(self):
+        """Output only. Running state of the job.
+
+        Valid states include 'PENDING', 'RUNNING', and 'DONE'.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatus.FIELDS.state
+
+        Returns:
+            Optional[str]:
+                the state (None until set from the server).
+        """
+        status = self._properties.get("status", {})
+        return status.get("state")
+
+    def _set_properties(self, api_response):
+        """Update properties from resource in body of ``api_response``
+
+        Args:
+            api_response (Dict): response returned from an API call.
+        """
+        cleaned = api_response.copy()
+        statistics = cleaned.setdefault("statistics", {})
+        if "creationTime" in statistics:
+            statistics["creationTime"] = float(statistics["creationTime"])
+        if "startTime" in statistics:
+            statistics["startTime"] = float(statistics["startTime"])
+        if "endTime" in statistics:
+            statistics["endTime"] = float(statistics["endTime"])
+
+        self._properties = cleaned
+
+        # For Future interface
+        self._set_future_result()
+
+    @classmethod
+    def _check_resource_config(cls, resource):
+        """Helper for :meth:`from_api_repr`
+
+        Args:
+            resource (Dict): resource for the job.
+
+        Raises:
+            KeyError:
+                If the resource has no identifier, or
+                is missing the appropriate configuration.
+        """
+        if "jobReference" not in resource or "jobId" not in resource["jobReference"]:
+            raise KeyError(
+                "Resource lacks required identity information: "
+                '["jobReference"]["jobId"]'
+            )
+        if (
+            "configuration" not in resource
+            or cls._JOB_TYPE not in resource["configuration"]
+        ):
+            raise KeyError(
+                "Resource lacks required configuration: "
+                '["configuration"]["%s"]' % cls._JOB_TYPE
+            )
+
+    def to_api_repr(self):
+        """Generate a resource for the job."""
+        return copy.deepcopy(self._properties)
+
+    _build_resource = to_api_repr  # backward-compatibility alias
+
+    def _begin(self, client=None, retry=DEFAULT_RETRY, timeout=None):
+        """API call:  begin the job via a POST request
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/insert
+
+        Args:
+            client (Optional[google.cloud.bigquery.client.Client]):
+                The client to use. If not passed, falls back to the ``client``
+                associated with the job object or``NoneType``
+            retry (Optional[google.api_core.retry.Retry]):
+                How to retry the RPC.
+            timeout (Optional[float]):
+                The number of seconds to wait for the underlying HTTP transport
+                before using ``retry``.
+
+        Raises:
+            ValueError:
+                If the job has already begun.
+        """
+        if self.state is not None:
+            raise ValueError("Job already begun.")
+
+        client = self._require_client(client)
+        path = "/projects/%s/jobs" % (self.project,)
+
+        # jobs.insert is idempotent because we ensure that every new
+        # job has an ID.
+        span_attributes = {"path": path}
+        api_response = client._call_api(
+            retry,
+            span_name="BigQuery.job.begin",
+            span_attributes=span_attributes,
+            job_ref=self,
+            method="POST",
+            path=path,
+            data=self.to_api_repr(),
+            timeout=timeout,
+        )
+        self._set_properties(api_response)
+
+    def exists(
+        self,
+        client=None,
+        retry: "retries.Retry" = DEFAULT_RETRY,
+        timeout: Optional[float] = None,
+    ) -> bool:
+        """API call:  test for the existence of the job via a GET request
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/get
+
+        Args:
+            client (Optional[google.cloud.bigquery.client.Client]):
+                the client to use.  If not passed, falls back to the
+                ``client`` stored on the current dataset.
+
+            retry (Optional[google.api_core.retry.Retry]): How to retry the RPC.
+            timeout (Optional[float]):
+                The number of seconds to wait for the underlying HTTP transport
+                before using ``retry``.
+
+        Returns:
+            bool: Boolean indicating existence of the job.
+        """
+        client = self._require_client(client)
+
+        extra_params = {"fields": "id"}
+        if self.location:
+            extra_params["location"] = self.location
+
+        try:
+            span_attributes = {"path": self.path}
+
+            client._call_api(
+                retry,
+                span_name="BigQuery.job.exists",
+                span_attributes=span_attributes,
+                job_ref=self,
+                method="GET",
+                path=self.path,
+                query_params=extra_params,
+                timeout=timeout,
+            )
+        except exceptions.NotFound:
+            return False
+        else:
+            return True
+
+    def reload(
+        self,
+        client=None,
+        retry: "retries.Retry" = DEFAULT_RETRY,
+        timeout: Optional[float] = DEFAULT_GET_JOB_TIMEOUT,
+    ):
+        """API call:  refresh job properties via a GET request.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/get
+
+        Args:
+            client (Optional[google.cloud.bigquery.client.Client]):
+                the client to use.  If not passed, falls back to the
+                ``client`` stored on the current dataset.
+
+            retry (Optional[google.api_core.retry.Retry]): How to retry the RPC.
+            timeout (Optional[float]):
+                The number of seconds to wait for the underlying HTTP transport
+                before using ``retry``.
+        """
+        client = self._require_client(client)
+
+        got_job = client.get_job(
+            self,
+            project=self.project,
+            location=self.location,
+            retry=retry,
+            timeout=timeout,
+        )
+        self._set_properties(got_job._properties)
+
+    def cancel(
+        self,
+        client=None,
+        retry: Optional[retries.Retry] = DEFAULT_RETRY,
+        timeout: Optional[float] = None,
+    ) -> bool:
+        """API call:  cancel job via a POST request
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/cancel
+
+        Args:
+            client (Optional[google.cloud.bigquery.client.Client]):
+                the client to use.  If not passed, falls back to the
+                ``client`` stored on the current dataset.
+            retry (Optional[google.api_core.retry.Retry]): How to retry the RPC.
+            timeout (Optional[float]):
+                The number of seconds to wait for the underlying HTTP transport
+                before using ``retry``
+
+        Returns:
+            bool: Boolean indicating that the cancel request was sent.
+        """
+        client = self._require_client(client)
+
+        extra_params = {}
+        if self.location:
+            extra_params["location"] = self.location
+
+        path = "{}/cancel".format(self.path)
+        span_attributes = {"path": path}
+
+        api_response = client._call_api(
+            retry,
+            span_name="BigQuery.job.cancel",
+            span_attributes=span_attributes,
+            job_ref=self,
+            method="POST",
+            path=path,
+            query_params=extra_params,
+            timeout=timeout,
+        )
+        self._set_properties(api_response["job"])
+        # The Future interface requires that we return True if the *attempt*
+        # to cancel was successful.
+        return True
+
+    # The following methods implement the PollingFuture interface. Note that
+    # the methods above are from the pre-Future interface and are left for
+    # compatibility. The only "overloaded" method is :meth:`cancel`, which
+    # satisfies both interfaces.
+
+    def _set_future_result(self):
+        """Set the result or exception from the job if it is complete."""
+        # This must be done in a lock to prevent the polling thread
+        # and main thread from both executing the completion logic
+        # at the same time.
+        with self._completion_lock:
+            # If the operation isn't complete or if the result has already been
+            # set, do not call set_result/set_exception again.
+            # Note: self._result_set is set to True in set_result and
+            # set_exception, in case those methods are invoked directly.
+            if not self.done(reload=False) or self._result_set:
+                return
+
+            if self.error_result is not None:
+                exception = _error_result_to_exception(
+                    self.error_result, self.errors or ()
+                )
+                self.set_exception(exception)
+            else:
+                self.set_result(self)
+
+    def done(
+        self,
+        retry: "retries.Retry" = DEFAULT_RETRY,
+        timeout: Optional[float] = DEFAULT_GET_JOB_TIMEOUT,
+        reload: bool = True,
+    ) -> bool:
+        """Checks if the job is complete.
+
+        Args:
+            retry (Optional[google.api_core.retry.Retry]):
+                How to retry the RPC. If the job state is ``DONE``, retrying is aborted
+                early, as the job will not change anymore.
+            timeout (Optional[float]):
+                The number of seconds to wait for the underlying HTTP transport
+                before using ``retry``.
+            reload (Optional[bool]):
+                If ``True``, make an API call to refresh the job state of
+                unfinished jobs before checking. Default ``True``.
+
+        Returns:
+            bool: True if the job is complete, False otherwise.
+        """
+        # Do not refresh is the state is already done, as the job will not
+        # change once complete.
+        if self.state != _DONE_STATE and reload:
+            self.reload(retry=retry, timeout=timeout)
+        return self.state == _DONE_STATE
+
+    def result(  # type: ignore  # (incompatible with supertype)
+        self,
+        retry: Optional[retries.Retry] = DEFAULT_RETRY,
+        timeout: Optional[float] = None,
+    ) -> "_AsyncJob":
+        """Start the job and wait for it to complete and get the result.
+
+        Args:
+            retry (Optional[google.api_core.retry.Retry]):
+                How to retry the RPC. If the job state is ``DONE``, retrying is aborted
+                early, as the job will not change anymore.
+            timeout (Optional[float]):
+                The number of seconds to wait for the underlying HTTP transport
+                before using ``retry``.
+                If multiple requests are made under the hood, ``timeout``
+                applies to each individual request.
+
+        Returns:
+            _AsyncJob: This instance.
+
+        Raises:
+            google.cloud.exceptions.GoogleAPICallError:
+                if the job failed.
+            concurrent.futures.TimeoutError:
+                if the job did not complete in the given timeout.
+        """
+        if self.state is None:
+            self._begin(retry=retry, timeout=timeout)
+
+        return super(_AsyncJob, self).result(timeout=timeout, retry=retry)
+
+    def cancelled(self):
+        """Check if the job has been cancelled.
+
+        This always returns False. It's not possible to check if a job was
+        cancelled in the API. This method is here to satisfy the interface
+        for :class:`google.api_core.future.Future`.
+
+        Returns:
+            bool: False
+        """
+        return (
+            self.error_result is not None
+            and self.error_result.get("reason") == _STOPPED_REASON
+        )
+
+    def __repr__(self):
+        result = (
+            f"{self.__class__.__name__}<"
+            f"project={self.project}, location={self.location}, id={self.job_id}"
+            ">"
+        )
+        return result
+
+
+class ScriptStackFrame(object):
+    """Stack frame showing the line/column/procedure name where the current
+    evaluation happened.
+
+    Args:
+        resource (Map[str, Any]): JSON representation of object.
+    """
+
+    def __init__(self, resource):
+        self._properties = resource
+
+    @property
+    def procedure_id(self):
+        """Optional[str]: Name of the active procedure.
+
+        Omitted if in a top-level script.
+        """
+        return self._properties.get("procedureId")
+
+    @property
+    def text(self):
+        """str: Text of the current statement/expression."""
+        return self._properties.get("text")
+
+    @property
+    def start_line(self):
+        """int: One-based start line."""
+        return _helpers._int_or_none(self._properties.get("startLine"))
+
+    @property
+    def start_column(self):
+        """int: One-based start column."""
+        return _helpers._int_or_none(self._properties.get("startColumn"))
+
+    @property
+    def end_line(self):
+        """int: One-based end line."""
+        return _helpers._int_or_none(self._properties.get("endLine"))
+
+    @property
+    def end_column(self):
+        """int: One-based end column."""
+        return _helpers._int_or_none(self._properties.get("endColumn"))
+
+
+class ScriptStatistics(object):
+    """Statistics for a child job of a script.
+
+    Args:
+        resource (Map[str, Any]): JSON representation of object.
+    """
+
+    def __init__(self, resource):
+        self._properties = resource
+
+    @property
+    def stack_frames(self) -> Sequence[ScriptStackFrame]:
+        """Stack trace where the current evaluation happened.
+
+        Shows line/column/procedure name of each frame on the stack at the
+        point where the current evaluation happened.
+
+        The leaf frame is first, the primary script is last.
+        """
+        return [
+            ScriptStackFrame(frame) for frame in self._properties.get("stackFrames", [])
+        ]
+
+    @property
+    def evaluation_kind(self) -> Optional[str]:
+        """str: Indicates the type of child job.
+
+        Possible values include ``STATEMENT`` and ``EXPRESSION``.
+        """
+        return self._properties.get("evaluationKind")
+
+
+class SessionInfo:
+    """[Preview] Information of the session if this job is part of one.
+
+    .. versionadded:: 2.29.0
+
+    Args:
+        resource (Map[str, Any]): JSON representation of object.
+    """
+
+    def __init__(self, resource):
+        self._properties = resource
+
+    @property
+    def session_id(self) -> Optional[str]:
+        """The ID of the session."""
+        return self._properties.get("sessionId")
+
+
+class UnknownJob(_AsyncJob):
+    """A job whose type cannot be determined."""
+
+    @classmethod
+    def from_api_repr(cls, resource: dict, client) -> "UnknownJob":
+        """Construct an UnknownJob from the JSON representation.
+
+        Args:
+            resource (Dict): JSON representation of a job.
+            client (google.cloud.bigquery.client.Client):
+                Client connected to BigQuery API.
+
+        Returns:
+            UnknownJob: Job corresponding to the resource.
+        """
+        job_ref_properties = resource.get(
+            "jobReference", {"projectId": client.project, "jobId": None}
+        )
+        job_ref = _JobReference._from_api_repr(job_ref_properties)
+        job = cls(job_ref, client)
+        # Populate the job reference with the project, even if it has been
+        # redacted, because we know it should equal that of the request.
+        resource["jobReference"] = job_ref_properties
+        job._properties = resource
+        return job

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/job/copy_.py

@@ -0,0 +1,282 @@
+# Copyright 2015 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.
+
+"""Classes for copy jobs."""
+
+import typing
+from typing import Optional
+
+from google.cloud.bigquery.encryption_configuration import EncryptionConfiguration
+from google.cloud.bigquery import _helpers
+from google.cloud.bigquery.table import TableReference
+
+from google.cloud.bigquery.job.base import _AsyncJob
+from google.cloud.bigquery.job.base import _JobConfig
+from google.cloud.bigquery.job.base import _JobReference
+
+
+class OperationType:
+    """Different operation types supported in table copy job.
+
+    https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#operationtype
+    """
+
+    OPERATION_TYPE_UNSPECIFIED = "OPERATION_TYPE_UNSPECIFIED"
+    """Unspecified operation type."""
+
+    COPY = "COPY"
+    """The source and destination table have the same table type."""
+
+    SNAPSHOT = "SNAPSHOT"
+    """The source table type is TABLE and the destination table type is SNAPSHOT."""
+
+    CLONE = "CLONE"
+    """The source table type is TABLE and the destination table type is CLONE."""
+
+    RESTORE = "RESTORE"
+    """The source table type is SNAPSHOT and the destination table type is TABLE."""
+
+
+class CopyJobConfig(_JobConfig):
+    """Configuration options for copy jobs.
+
+    All properties in this class are optional. Values which are :data:`None` ->
+    server defaults. Set properties on the constructed configuration by using
+    the property name as the name of a keyword argument.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super(CopyJobConfig, self).__init__("copy", **kwargs)
+
+    @property
+    def create_disposition(self):
+        """google.cloud.bigquery.job.CreateDisposition: Specifies behavior
+        for creating tables.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy.FIELDS.create_disposition
+        """
+        return self._get_sub_prop("createDisposition")
+
+    @create_disposition.setter
+    def create_disposition(self, value):
+        self._set_sub_prop("createDisposition", value)
+
+    @property
+    def write_disposition(self):
+        """google.cloud.bigquery.job.WriteDisposition: Action that occurs if
+        the destination table already exists.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy.FIELDS.write_disposition
+        """
+        return self._get_sub_prop("writeDisposition")
+
+    @write_disposition.setter
+    def write_disposition(self, value):
+        self._set_sub_prop("writeDisposition", value)
+
+    @property
+    def destination_encryption_configuration(self):
+        """google.cloud.bigquery.encryption_configuration.EncryptionConfiguration: Custom
+        encryption configuration for the destination table.
+
+        Custom encryption configuration (e.g., Cloud KMS keys) or :data:`None`
+        if using default encryption.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy.FIELDS.destination_encryption_configuration
+        """
+        prop = self._get_sub_prop("destinationEncryptionConfiguration")
+        if prop is not None:
+            prop = EncryptionConfiguration.from_api_repr(prop)
+        return prop
+
+    @destination_encryption_configuration.setter
+    def destination_encryption_configuration(self, value):
+        api_repr = value
+        if value is not None:
+            api_repr = value.to_api_repr()
+        self._set_sub_prop("destinationEncryptionConfiguration", api_repr)
+
+    @property
+    def operation_type(self) -> str:
+        """The operation to perform with this copy job.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy.FIELDS.operation_type
+        """
+        return self._get_sub_prop(
+            "operationType", OperationType.OPERATION_TYPE_UNSPECIFIED
+        )
+
+    @operation_type.setter
+    def operation_type(self, value: Optional[str]):
+        if value is None:
+            value = OperationType.OPERATION_TYPE_UNSPECIFIED
+        self._set_sub_prop("operationType", value)
+
+    @property
+    def destination_expiration_time(self) -> str:
+        """google.cloud.bigquery.job.DestinationExpirationTime: The time when the
+        destination table expires. Expired tables will be deleted and their storage reclaimed.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationTableCopy.FIELDS.destination_expiration_time
+        """
+        return self._get_sub_prop("destinationExpirationTime")
+
+    @destination_expiration_time.setter
+    def destination_expiration_time(self, value: str):
+        self._set_sub_prop("destinationExpirationTime", value)
+
+
+class CopyJob(_AsyncJob):
+    """Asynchronous job: copy data into a table from other tables.
+
+    Args:
+        job_id (str): the job's ID, within the project belonging to ``client``.
+
+        sources (List[google.cloud.bigquery.table.TableReference]): Table from which data is to be loaded.
+
+        destination (google.cloud.bigquery.table.TableReference): Table into which data is to be loaded.
+
+        client (google.cloud.bigquery.client.Client):
+            A client which holds credentials and project configuration
+            for the dataset (which requires a project).
+
+        job_config (Optional[google.cloud.bigquery.job.CopyJobConfig]):
+            Extra configuration options for the copy job.
+    """
+
+    _JOB_TYPE = "copy"
+    _CONFIG_CLASS = CopyJobConfig
+
+    def __init__(self, job_id, sources, destination, client, job_config=None):
+        super(CopyJob, self).__init__(job_id, client)
+
+        if job_config is not None:
+            self._properties["configuration"] = job_config._properties
+
+        if destination:
+            _helpers._set_sub_prop(
+                self._properties,
+                ["configuration", "copy", "destinationTable"],
+                destination.to_api_repr(),
+            )
+
+        if sources:
+            source_resources = [source.to_api_repr() for source in sources]
+            _helpers._set_sub_prop(
+                self._properties,
+                ["configuration", "copy", "sourceTables"],
+                source_resources,
+            )
+
+    @property
+    def configuration(self) -> CopyJobConfig:
+        """The configuration for this copy job."""
+        return typing.cast(CopyJobConfig, super().configuration)
+
+    @property
+    def destination(self):
+        """google.cloud.bigquery.table.TableReference: Table into which data
+        is to be loaded.
+        """
+        return TableReference.from_api_repr(
+            _helpers._get_sub_prop(
+                self._properties, ["configuration", "copy", "destinationTable"]
+            )
+        )
+
+    @property
+    def sources(self):
+        """List[google.cloud.bigquery.table.TableReference]): Table(s) from
+        which data is to be loaded.
+        """
+        source_configs = _helpers._get_sub_prop(
+            self._properties, ["configuration", "copy", "sourceTables"]
+        )
+        if source_configs is None:
+            single = _helpers._get_sub_prop(
+                self._properties, ["configuration", "copy", "sourceTable"]
+            )
+            if single is None:
+                raise KeyError("Resource missing 'sourceTables' / 'sourceTable'")
+            source_configs = [single]
+
+        sources = []
+        for source_config in source_configs:
+            table_ref = TableReference.from_api_repr(source_config)
+            sources.append(table_ref)
+        return sources
+
+    @property
+    def create_disposition(self):
+        """See
+        :attr:`google.cloud.bigquery.job.CopyJobConfig.create_disposition`.
+        """
+        return self.configuration.create_disposition
+
+    @property
+    def write_disposition(self):
+        """See
+        :attr:`google.cloud.bigquery.job.CopyJobConfig.write_disposition`.
+        """
+        return self.configuration.write_disposition
+
+    @property
+    def destination_encryption_configuration(self):
+        """google.cloud.bigquery.encryption_configuration.EncryptionConfiguration: Custom
+        encryption configuration for the destination table.
+
+        Custom encryption configuration (e.g., Cloud KMS keys) or :data:`None`
+        if using default encryption.
+
+        See
+        :attr:`google.cloud.bigquery.job.CopyJobConfig.destination_encryption_configuration`.
+        """
+        return self.configuration.destination_encryption_configuration
+
+    def to_api_repr(self):
+        """Generate a resource for :meth:`_begin`."""
+        # Exclude statistics, if set.
+        return {
+            "jobReference": self._properties["jobReference"],
+            "configuration": self._properties["configuration"],
+        }
+
+    @classmethod
+    def from_api_repr(cls, resource, client):
+        """Factory: construct a job given its API representation
+
+        .. note::
+
+           This method assumes that the project found in the resource matches
+           the client's project.
+
+        Args:
+            resource (Dict): dataset job representation returned from the API
+            client (google.cloud.bigquery.client.Client):
+                Client which holds credentials and project
+                configuration for the dataset.
+
+        Returns:
+            google.cloud.bigquery.job.CopyJob: Job parsed from ``resource``.
+        """
+        cls._check_resource_config(resource)
+        job_ref = _JobReference._from_api_repr(resource["jobReference"])
+        job = cls(job_ref, None, None, client=client)
+        job._set_properties(resource)
+        return job

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/job/extract.py

@@ -0,0 +1,271 @@
+# Copyright 2015 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.
+
+"""Classes for extract (export) jobs."""
+
+import typing
+
+from google.cloud.bigquery import _helpers
+from google.cloud.bigquery.model import ModelReference
+from google.cloud.bigquery.table import Table
+from google.cloud.bigquery.table import TableListItem
+from google.cloud.bigquery.table import TableReference
+from google.cloud.bigquery.job.base import _AsyncJob
+from google.cloud.bigquery.job.base import _JobConfig
+from google.cloud.bigquery.job.base import _JobReference
+
+
+class ExtractJobConfig(_JobConfig):
+    """Configuration options for extract jobs.
+
+    All properties in this class are optional. Values which are :data:`None` ->
+    server defaults. Set properties on the constructed configuration by using
+    the property name as the name of a keyword argument.
+    """
+
+    def __init__(self, **kwargs):
+        super(ExtractJobConfig, self).__init__("extract", **kwargs)
+
+    @property
+    def compression(self):
+        """google.cloud.bigquery.job.Compression: Compression type to use for
+        exported files.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationExtract.FIELDS.compression
+        """
+        return self._get_sub_prop("compression")
+
+    @compression.setter
+    def compression(self, value):
+        self._set_sub_prop("compression", value)
+
+    @property
+    def destination_format(self):
+        """google.cloud.bigquery.job.DestinationFormat: Exported file format.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationExtract.FIELDS.destination_format
+        """
+        return self._get_sub_prop("destinationFormat")
+
+    @destination_format.setter
+    def destination_format(self, value):
+        self._set_sub_prop("destinationFormat", value)
+
+    @property
+    def field_delimiter(self):
+        """str: Delimiter to use between fields in the exported data.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationExtract.FIELDS.field_delimiter
+        """
+        return self._get_sub_prop("fieldDelimiter")
+
+    @field_delimiter.setter
+    def field_delimiter(self, value):
+        self._set_sub_prop("fieldDelimiter", value)
+
+    @property
+    def print_header(self):
+        """bool: Print a header row in the exported data.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationExtract.FIELDS.print_header
+        """
+        return self._get_sub_prop("printHeader")
+
+    @print_header.setter
+    def print_header(self, value):
+        self._set_sub_prop("printHeader", value)
+
+    @property
+    def use_avro_logical_types(self):
+        """bool: For loads of Avro data, governs whether Avro logical types are
+        converted to their corresponding BigQuery types (e.g. TIMESTAMP) rather than
+        raw types (e.g. INTEGER).
+        """
+        return self._get_sub_prop("useAvroLogicalTypes")
+
+    @use_avro_logical_types.setter
+    def use_avro_logical_types(self, value):
+        self._set_sub_prop("useAvroLogicalTypes", bool(value))
+
+
+class ExtractJob(_AsyncJob):
+    """Asynchronous job: extract data from a table into Cloud Storage.
+
+    Args:
+        job_id (str): the job's ID.
+
+        source (Union[ \
+            google.cloud.bigquery.table.TableReference, \
+            google.cloud.bigquery.model.ModelReference \
+        ]):
+            Table or Model from which data is to be loaded or extracted.
+
+        destination_uris (List[str]):
+            URIs describing where the extracted data will be written in Cloud
+            Storage, using the format ``gs://<bucket_name>/<object_name_or_glob>``.
+
+        client (google.cloud.bigquery.client.Client):
+            A client which holds credentials and project configuration.
+
+        job_config (Optional[google.cloud.bigquery.job.ExtractJobConfig]):
+            Extra configuration options for the extract job.
+    """
+
+    _JOB_TYPE = "extract"
+    _CONFIG_CLASS = ExtractJobConfig
+
+    def __init__(self, job_id, source, destination_uris, client, job_config=None):
+        super(ExtractJob, self).__init__(job_id, client)
+
+        if job_config is not None:
+            self._properties["configuration"] = job_config._properties
+
+        if source:
+            source_ref = {"projectId": source.project, "datasetId": source.dataset_id}
+
+            if isinstance(source, (Table, TableListItem, TableReference)):
+                source_ref["tableId"] = source.table_id
+                source_key = "sourceTable"
+            else:
+                source_ref["modelId"] = source.model_id
+                source_key = "sourceModel"
+
+            _helpers._set_sub_prop(
+                self._properties, ["configuration", "extract", source_key], source_ref
+            )
+
+        if destination_uris:
+            _helpers._set_sub_prop(
+                self._properties,
+                ["configuration", "extract", "destinationUris"],
+                destination_uris,
+            )
+
+    @property
+    def configuration(self) -> ExtractJobConfig:
+        """The configuration for this extract job."""
+        return typing.cast(ExtractJobConfig, super().configuration)
+
+    @property
+    def source(self):
+        """Union[ \
+            google.cloud.bigquery.table.TableReference, \
+            google.cloud.bigquery.model.ModelReference \
+        ]: Table or Model from which data is to be loaded or extracted.
+        """
+        source_config = _helpers._get_sub_prop(
+            self._properties, ["configuration", "extract", "sourceTable"]
+        )
+        if source_config:
+            return TableReference.from_api_repr(source_config)
+        else:
+            source_config = _helpers._get_sub_prop(
+                self._properties, ["configuration", "extract", "sourceModel"]
+            )
+            return ModelReference.from_api_repr(source_config)
+
+    @property
+    def destination_uris(self):
+        """List[str]: URIs describing where the extracted data will be
+        written in Cloud Storage, using the format
+        ``gs://<bucket_name>/<object_name_or_glob>``.
+        """
+        return _helpers._get_sub_prop(
+            self._properties, ["configuration", "extract", "destinationUris"]
+        )
+
+    @property
+    def compression(self):
+        """See
+        :attr:`google.cloud.bigquery.job.ExtractJobConfig.compression`.
+        """
+        return self.configuration.compression
+
+    @property
+    def destination_format(self):
+        """See
+        :attr:`google.cloud.bigquery.job.ExtractJobConfig.destination_format`.
+        """
+        return self.configuration.destination_format
+
+    @property
+    def field_delimiter(self):
+        """See
+        :attr:`google.cloud.bigquery.job.ExtractJobConfig.field_delimiter`.
+        """
+        return self.configuration.field_delimiter
+
+    @property
+    def print_header(self):
+        """See
+        :attr:`google.cloud.bigquery.job.ExtractJobConfig.print_header`.
+        """
+        return self.configuration.print_header
+
+    @property
+    def destination_uri_file_counts(self):
+        """Return file counts from job statistics, if present.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatistics4.FIELDS.destination_uri_file_counts
+
+        Returns:
+            List[int]:
+                A list of integer counts, each representing the number of files
+                per destination URI or URI pattern specified in the extract
+                configuration. These values will be in the same order as the URIs
+                specified in the 'destinationUris' field.  Returns None if job is
+                not yet complete.
+        """
+        counts = self._job_statistics().get("destinationUriFileCounts")
+        if counts is not None:
+            return [int(count) for count in counts]
+        return None
+
+    def to_api_repr(self):
+        """Generate a resource for :meth:`_begin`."""
+        # Exclude statistics, if set.
+        return {
+            "jobReference": self._properties["jobReference"],
+            "configuration": self._properties["configuration"],
+        }
+
+    @classmethod
+    def from_api_repr(cls, resource: dict, client) -> "ExtractJob":
+        """Factory:  construct a job given its API representation
+
+        .. note::
+
+           This method assumes that the project found in the resource matches
+           the client's project.
+
+        Args:
+            resource (Dict): dataset job representation returned from the API
+
+            client (google.cloud.bigquery.client.Client):
+                Client which holds credentials and project
+                configuration for the dataset.
+
+        Returns:
+            google.cloud.bigquery.job.ExtractJob: Job parsed from ``resource``.
+        """
+        cls._check_resource_config(resource)
+        job_ref = _JobReference._from_api_repr(resource["jobReference"])
+        job = cls(job_ref, None, None, client=client)
+        job._set_properties(resource)
+        return job

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/job/load.py

@@ -0,0 +1,1185 @@
+# Copyright 2015 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.
+
+"""Classes for load jobs."""
+
+import typing
+from typing import FrozenSet, List, Iterable, Optional, Union
+
+from google.cloud.bigquery.encryption_configuration import EncryptionConfiguration
+from google.cloud.bigquery.enums import SourceColumnMatch
+from google.cloud.bigquery.external_config import HivePartitioningOptions
+from google.cloud.bigquery.format_options import ParquetOptions
+from google.cloud.bigquery import _helpers
+from google.cloud.bigquery.schema import SchemaField
+from google.cloud.bigquery.schema import _to_schema_fields
+from google.cloud.bigquery.table import RangePartitioning
+from google.cloud.bigquery.table import TableReference
+from google.cloud.bigquery.table import TimePartitioning
+from google.cloud.bigquery.job.base import _AsyncJob
+from google.cloud.bigquery.job.base import _JobConfig
+from google.cloud.bigquery.job.base import _JobReference
+from google.cloud.bigquery.query import ConnectionProperty
+
+
+class ColumnNameCharacterMap:
+    """Indicates the character map used for column names.
+
+    https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#columnnamecharactermap
+    """
+
+    COLUMN_NAME_CHARACTER_MAP_UNSPECIFIED = "COLUMN_NAME_CHARACTER_MAP_UNSPECIFIED"
+    """Unspecified column name character map."""
+
+    STRICT = "STRICT"
+    """Support flexible column name and reject invalid column names."""
+
+    V1 = "V1"
+    """	Support alphanumeric + underscore characters and names must start with
+    a letter or underscore. Invalid column names will be normalized."""
+
+    V2 = "V2"
+    """Support flexible column name. Invalid column names will be normalized."""
+
+
+class LoadJobConfig(_JobConfig):
+    """Configuration options for load jobs.
+
+    Set properties on the constructed configuration by using the property name
+    as the name of a keyword argument. Values which are unset or :data:`None`
+    use the BigQuery REST API default values. See the `BigQuery REST API
+    reference documentation
+    <https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad>`_
+    for a list of default values.
+
+    Required options differ based on the
+    :attr:`~google.cloud.bigquery.job.LoadJobConfig.source_format` value.
+    For example, the BigQuery API's default value for
+    :attr:`~google.cloud.bigquery.job.LoadJobConfig.source_format` is ``"CSV"``.
+    When loading a CSV file, either
+    :attr:`~google.cloud.bigquery.job.LoadJobConfig.schema` must be set or
+    :attr:`~google.cloud.bigquery.job.LoadJobConfig.autodetect` must be set to
+    :data:`True`.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super(LoadJobConfig, self).__init__("load", **kwargs)
+
+    @property
+    def allow_jagged_rows(self):
+        """Optional[bool]: Allow missing trailing optional columns (CSV only).
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.allow_jagged_rows
+        """
+        return self._get_sub_prop("allowJaggedRows")
+
+    @allow_jagged_rows.setter
+    def allow_jagged_rows(self, value):
+        self._set_sub_prop("allowJaggedRows", value)
+
+    @property
+    def allow_quoted_newlines(self):
+        """Optional[bool]: Allow quoted data containing newline characters (CSV only).
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.allow_quoted_newlines
+        """
+        return self._get_sub_prop("allowQuotedNewlines")
+
+    @allow_quoted_newlines.setter
+    def allow_quoted_newlines(self, value):
+        self._set_sub_prop("allowQuotedNewlines", value)
+
+    @property
+    def autodetect(self):
+        """Optional[bool]: Automatically infer the schema from a sample of the data.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.autodetect
+        """
+        return self._get_sub_prop("autodetect")
+
+    @autodetect.setter
+    def autodetect(self, value):
+        self._set_sub_prop("autodetect", value)
+
+    @property
+    def clustering_fields(self):
+        """Optional[List[str]]: Fields defining clustering for the table
+
+        (Defaults to :data:`None`).
+
+        Clustering fields are immutable after table creation.
+
+        .. note::
+
+           BigQuery supports clustering for both partitioned and
+           non-partitioned tables.
+        """
+        prop = self._get_sub_prop("clustering")
+        if prop is not None:
+            return list(prop.get("fields", ()))
+
+    @clustering_fields.setter
+    def clustering_fields(self, value):
+        """Optional[List[str]]: Fields defining clustering for the table
+
+        (Defaults to :data:`None`).
+        """
+        if value is not None:
+            self._set_sub_prop("clustering", {"fields": value})
+        else:
+            self._del_sub_prop("clustering")
+
+    @property
+    def connection_properties(self) -> List[ConnectionProperty]:
+        """Connection properties.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.connection_properties
+
+        .. versionadded:: 3.7.0
+        """
+        resource = self._get_sub_prop("connectionProperties", [])
+        return [ConnectionProperty.from_api_repr(prop) for prop in resource]
+
+    @connection_properties.setter
+    def connection_properties(self, value: Iterable[ConnectionProperty]):
+        self._set_sub_prop(
+            "connectionProperties",
+            [prop.to_api_repr() for prop in value],
+        )
+
+    @property
+    def create_disposition(self):
+        """Optional[google.cloud.bigquery.job.CreateDisposition]: Specifies behavior
+        for creating tables.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.create_disposition
+        """
+        return self._get_sub_prop("createDisposition")
+
+    @create_disposition.setter
+    def create_disposition(self, value):
+        self._set_sub_prop("createDisposition", value)
+
+    @property
+    def create_session(self) -> Optional[bool]:
+        """[Preview] If :data:`True`, creates a new session, where
+        :attr:`~google.cloud.bigquery.job.LoadJob.session_info` will contain a
+        random server generated session id.
+
+        If :data:`False`, runs load job with an existing ``session_id`` passed in
+        :attr:`~google.cloud.bigquery.job.LoadJobConfig.connection_properties`,
+        otherwise runs load job in non-session mode.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.create_session
+
+        .. versionadded:: 3.7.0
+        """
+        return self._get_sub_prop("createSession")
+
+    @create_session.setter
+    def create_session(self, value: Optional[bool]):
+        self._set_sub_prop("createSession", value)
+
+    @property
+    def decimal_target_types(self) -> Optional[FrozenSet[str]]:
+        """Possible SQL data types to which the source decimal values are converted.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.decimal_target_types
+
+        .. versionadded:: 2.21.0
+        """
+        prop = self._get_sub_prop("decimalTargetTypes")
+        if prop is not None:
+            prop = frozenset(prop)
+        return prop
+
+    @decimal_target_types.setter
+    def decimal_target_types(self, value: Optional[Iterable[str]]):
+        if value is not None:
+            self._set_sub_prop("decimalTargetTypes", list(value))
+        else:
+            self._del_sub_prop("decimalTargetTypes")
+
+    @property
+    def destination_encryption_configuration(self):
+        """Optional[google.cloud.bigquery.encryption_configuration.EncryptionConfiguration]: Custom
+        encryption configuration for the destination table.
+
+        Custom encryption configuration (e.g., Cloud KMS keys) or :data:`None`
+        if using default encryption.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.destination_encryption_configuration
+        """
+        prop = self._get_sub_prop("destinationEncryptionConfiguration")
+        if prop is not None:
+            prop = EncryptionConfiguration.from_api_repr(prop)
+        return prop
+
+    @destination_encryption_configuration.setter
+    def destination_encryption_configuration(self, value):
+        api_repr = value
+        if value is not None:
+            api_repr = value.to_api_repr()
+            self._set_sub_prop("destinationEncryptionConfiguration", api_repr)
+        else:
+            self._del_sub_prop("destinationEncryptionConfiguration")
+
+    @property
+    def destination_table_description(self):
+        """Optional[str]: Description of the destination table.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#DestinationTableProperties.FIELDS.description
+        """
+        prop = self._get_sub_prop("destinationTableProperties")
+        if prop is not None:
+            return prop["description"]
+
+    @destination_table_description.setter
+    def destination_table_description(self, value):
+        keys = [self._job_type, "destinationTableProperties", "description"]
+        if value is not None:
+            _helpers._set_sub_prop(self._properties, keys, value)
+        else:
+            _helpers._del_sub_prop(self._properties, keys)
+
+    @property
+    def destination_table_friendly_name(self):
+        """Optional[str]: Name given to destination table.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#DestinationTableProperties.FIELDS.friendly_name
+        """
+        prop = self._get_sub_prop("destinationTableProperties")
+        if prop is not None:
+            return prop["friendlyName"]
+
+    @destination_table_friendly_name.setter
+    def destination_table_friendly_name(self, value):
+        keys = [self._job_type, "destinationTableProperties", "friendlyName"]
+        if value is not None:
+            _helpers._set_sub_prop(self._properties, keys, value)
+        else:
+            _helpers._del_sub_prop(self._properties, keys)
+
+    @property
+    def encoding(self):
+        """Optional[google.cloud.bigquery.job.Encoding]: The character encoding of the
+        data.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.encoding
+        """
+        return self._get_sub_prop("encoding")
+
+    @encoding.setter
+    def encoding(self, value):
+        self._set_sub_prop("encoding", value)
+
+    @property
+    def field_delimiter(self):
+        """Optional[str]: The separator for fields in a CSV file.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.field_delimiter
+        """
+        return self._get_sub_prop("fieldDelimiter")
+
+    @field_delimiter.setter
+    def field_delimiter(self, value):
+        self._set_sub_prop("fieldDelimiter", value)
+
+    @property
+    def hive_partitioning(self):
+        """Optional[:class:`~.external_config.HivePartitioningOptions`]: [Beta] When set, \
+        it configures hive partitioning support.
+
+        .. note::
+            **Experimental**. This feature is experimental and might change or
+            have limited support.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.hive_partitioning_options
+        """
+        prop = self._get_sub_prop("hivePartitioningOptions")
+        if prop is None:
+            return None
+        return HivePartitioningOptions.from_api_repr(prop)
+
+    @hive_partitioning.setter
+    def hive_partitioning(self, value):
+        if value is not None:
+            if isinstance(value, HivePartitioningOptions):
+                value = value.to_api_repr()
+            else:
+                raise TypeError("Expected a HivePartitioningOptions instance or None.")
+
+        self._set_sub_prop("hivePartitioningOptions", value)
+
+    @property
+    def ignore_unknown_values(self):
+        """Optional[bool]: Ignore extra values not represented in the table schema.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.ignore_unknown_values
+        """
+        return self._get_sub_prop("ignoreUnknownValues")
+
+    @ignore_unknown_values.setter
+    def ignore_unknown_values(self, value):
+        self._set_sub_prop("ignoreUnknownValues", value)
+
+    @property
+    def json_extension(self):
+        """Optional[str]: The extension to use for writing JSON data to BigQuery. Only supports GeoJSON currently.
+
+        See: https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.json_extension
+
+        """
+        return self._get_sub_prop("jsonExtension")
+
+    @json_extension.setter
+    def json_extension(self, value):
+        self._set_sub_prop("jsonExtension", value)
+
+    @property
+    def max_bad_records(self):
+        """Optional[int]: Number of invalid rows to ignore.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.max_bad_records
+        """
+        return _helpers._int_or_none(self._get_sub_prop("maxBadRecords"))
+
+    @max_bad_records.setter
+    def max_bad_records(self, value):
+        self._set_sub_prop("maxBadRecords", value)
+
+    @property
+    def null_marker(self):
+        """Optional[str]: Represents a null value (CSV only).
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.null_marker
+        """
+        return self._get_sub_prop("nullMarker")
+
+    @null_marker.setter
+    def null_marker(self, value):
+        self._set_sub_prop("nullMarker", value)
+
+    @property
+    def null_markers(self) -> Optional[List[str]]:
+        """Optional[List[str]]: A list of strings represented as SQL NULL values in a CSV file.
+
+        .. note::
+            null_marker and null_markers can't be set at the same time.
+            If null_marker is set, null_markers has to be not set.
+            If null_markers is set, null_marker has to be not set.
+            If both null_marker and null_markers are set at the same time, a user error would be thrown.
+            Any strings listed in null_markers, including empty string would be interpreted as SQL NULL.
+            This applies to all column types.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.null_markers
+        """
+        return self._get_sub_prop("nullMarkers")
+
+    @null_markers.setter
+    def null_markers(self, value: Optional[List[str]]):
+        self._set_sub_prop("nullMarkers", value)
+
+    @property
+    def preserve_ascii_control_characters(self):
+        """Optional[bool]: Preserves the embedded ASCII control characters when sourceFormat is set to CSV.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.preserve_ascii_control_characters
+        """
+        return self._get_sub_prop("preserveAsciiControlCharacters")
+
+    @preserve_ascii_control_characters.setter
+    def preserve_ascii_control_characters(self, value):
+        self._set_sub_prop("preserveAsciiControlCharacters", bool(value))
+
+    @property
+    def projection_fields(self) -> Optional[List[str]]:
+        """Optional[List[str]]: If
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.source_format` is set to
+        "DATASTORE_BACKUP", indicates which entity properties to load into
+        BigQuery from a Cloud Datastore backup.
+
+        Property names are case sensitive and must be top-level properties. If
+        no properties are specified, BigQuery loads all properties. If any
+        named property isn't found in the Cloud Datastore backup, an invalid
+        error is returned in the job result.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.projection_fields
+        """
+        return self._get_sub_prop("projectionFields")
+
+    @projection_fields.setter
+    def projection_fields(self, value: Optional[List[str]]):
+        self._set_sub_prop("projectionFields", value)
+
+    @property
+    def quote_character(self):
+        """Optional[str]: Character used to quote data sections (CSV only).
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.quote
+        """
+        return self._get_sub_prop("quote")
+
+    @quote_character.setter
+    def quote_character(self, value):
+        self._set_sub_prop("quote", value)
+
+    @property
+    def range_partitioning(self):
+        """Optional[google.cloud.bigquery.table.RangePartitioning]:
+        Configures range-based partitioning for destination table.
+
+        .. note::
+            **Beta**. The integer range partitioning feature is in a
+            pre-release state and might change or have limited support.
+
+        Only specify at most one of
+        :attr:`~google.cloud.bigquery.job.LoadJobConfig.time_partitioning` or
+        :attr:`~google.cloud.bigquery.job.LoadJobConfig.range_partitioning`.
+
+        Raises:
+            ValueError:
+                If the value is not
+                :class:`~google.cloud.bigquery.table.RangePartitioning` or
+                :data:`None`.
+        """
+        resource = self._get_sub_prop("rangePartitioning")
+        if resource is not None:
+            return RangePartitioning(_properties=resource)
+
+    @range_partitioning.setter
+    def range_partitioning(self, value):
+        resource = value
+        if isinstance(value, RangePartitioning):
+            resource = value._properties
+        elif value is not None:
+            raise ValueError(
+                "Expected value to be RangePartitioning or None, got {}.".format(value)
+            )
+        self._set_sub_prop("rangePartitioning", resource)
+
+    @property
+    def reference_file_schema_uri(self):
+        """Optional[str]:
+        When creating an external table, the user can provide a reference file with the
+        table schema. This is enabled for the following formats:
+
+        AVRO, PARQUET, ORC
+        """
+        return self._get_sub_prop("referenceFileSchemaUri")
+
+    @reference_file_schema_uri.setter
+    def reference_file_schema_uri(self, value):
+        return self._set_sub_prop("referenceFileSchemaUri", value)
+
+    @property
+    def schema(self):
+        """Optional[Sequence[Union[ \
+            :class:`~google.cloud.bigquery.schema.SchemaField`, \
+            Mapping[str, Any] \
+        ]]]: Schema of the destination table.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.schema
+        """
+        schema = _helpers._get_sub_prop(self._properties, ["load", "schema", "fields"])
+        if schema is None:
+            return
+        return [SchemaField.from_api_repr(field) for field in schema]
+
+    @schema.setter
+    def schema(self, value):
+        if value is None:
+            self._del_sub_prop("schema")
+            return
+
+        value = _to_schema_fields(value)
+
+        _helpers._set_sub_prop(
+            self._properties,
+            ["load", "schema", "fields"],
+            [field.to_api_repr() for field in value],
+        )
+
+    @property
+    def schema_update_options(self):
+        """Optional[List[google.cloud.bigquery.job.SchemaUpdateOption]]: Specifies
+        updates to the destination table schema to allow as a side effect of
+        the load job.
+        """
+        return self._get_sub_prop("schemaUpdateOptions")
+
+    @schema_update_options.setter
+    def schema_update_options(self, values):
+        self._set_sub_prop("schemaUpdateOptions", values)
+
+    @property
+    def skip_leading_rows(self):
+        """Optional[int]: Number of rows to skip when reading data (CSV only).
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.skip_leading_rows
+        """
+        return _helpers._int_or_none(self._get_sub_prop("skipLeadingRows"))
+
+    @skip_leading_rows.setter
+    def skip_leading_rows(self, value):
+        self._set_sub_prop("skipLeadingRows", str(value))
+
+    @property
+    def source_format(self):
+        """Optional[google.cloud.bigquery.job.SourceFormat]: File format of the data.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.source_format
+        """
+        return self._get_sub_prop("sourceFormat")
+
+    @source_format.setter
+    def source_format(self, value):
+        self._set_sub_prop("sourceFormat", value)
+
+    @property
+    def source_column_match(self) -> Optional[SourceColumnMatch]:
+        """Optional[google.cloud.bigquery.enums.SourceColumnMatch]: Controls the
+        strategy used to match loaded columns to the schema. If not set, a sensible
+        default is chosen based on how the schema is provided. If autodetect is
+        used, then columns are matched by name. Otherwise, columns are matched by
+        position. This is done to keep the behavior backward-compatible.
+
+        Acceptable values are:
+
+            SOURCE_COLUMN_MATCH_UNSPECIFIED: Unspecified column name match option.
+            POSITION: matches by position. This assumes that the columns are ordered
+            the same way as the schema.
+            NAME: matches by name. This reads the header row as column names and
+            reorders columns to match the field names in the schema.
+
+        See:
+
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.source_column_match
+        """
+        value = self._get_sub_prop("sourceColumnMatch")
+        return SourceColumnMatch(value) if value is not None else None
+
+    @source_column_match.setter
+    def source_column_match(self, value: Union[SourceColumnMatch, str, None]):
+        if value is not None and not isinstance(value, (SourceColumnMatch, str)):
+            raise TypeError(
+                "value must be a google.cloud.bigquery.enums.SourceColumnMatch, str, or None"
+            )
+        if isinstance(value, SourceColumnMatch):
+            value = value.value
+        self._set_sub_prop("sourceColumnMatch", value if value else None)
+
+    @property
+    def date_format(self) -> Optional[str]:
+        """Optional[str]: Date format used for parsing DATE values.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.date_format
+        """
+        return self._get_sub_prop("dateFormat")
+
+    @date_format.setter
+    def date_format(self, value: Optional[str]):
+        self._set_sub_prop("dateFormat", value)
+
+    @property
+    def datetime_format(self) -> Optional[str]:
+        """Optional[str]: Date format used for parsing DATETIME values.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.datetime_format
+        """
+        return self._get_sub_prop("datetimeFormat")
+
+    @datetime_format.setter
+    def datetime_format(self, value: Optional[str]):
+        self._set_sub_prop("datetimeFormat", value)
+
+    @property
+    def time_zone(self) -> Optional[str]:
+        """Optional[str]: Default time zone that will apply when parsing timestamp
+        values that have no specific time zone.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.time_zone
+        """
+        return self._get_sub_prop("timeZone")
+
+    @time_zone.setter
+    def time_zone(self, value: Optional[str]):
+        self._set_sub_prop("timeZone", value)
+
+    @property
+    def time_format(self) -> Optional[str]:
+        """Optional[str]: Date format used for parsing TIME values.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.time_format
+        """
+        return self._get_sub_prop("timeFormat")
+
+    @time_format.setter
+    def time_format(self, value: Optional[str]):
+        self._set_sub_prop("timeFormat", value)
+
+    @property
+    def timestamp_format(self) -> Optional[str]:
+        """Optional[str]: Date format used for parsing TIMESTAMP values.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.timestamp_format
+        """
+        return self._get_sub_prop("timestampFormat")
+
+    @timestamp_format.setter
+    def timestamp_format(self, value: Optional[str]):
+        self._set_sub_prop("timestampFormat", value)
+
+    @property
+    def time_partitioning(self):
+        """Optional[google.cloud.bigquery.table.TimePartitioning]: Specifies time-based
+        partitioning for the destination table.
+
+        Only specify at most one of
+        :attr:`~google.cloud.bigquery.job.LoadJobConfig.time_partitioning` or
+        :attr:`~google.cloud.bigquery.job.LoadJobConfig.range_partitioning`.
+        """
+        prop = self._get_sub_prop("timePartitioning")
+        if prop is not None:
+            prop = TimePartitioning.from_api_repr(prop)
+        return prop
+
+    @time_partitioning.setter
+    def time_partitioning(self, value):
+        api_repr = value
+        if value is not None:
+            api_repr = value.to_api_repr()
+            self._set_sub_prop("timePartitioning", api_repr)
+        else:
+            self._del_sub_prop("timePartitioning")
+
+    @property
+    def use_avro_logical_types(self):
+        """Optional[bool]: For loads of Avro data, governs whether Avro logical types are
+        converted to their corresponding BigQuery types (e.g. TIMESTAMP) rather than
+        raw types (e.g. INTEGER).
+        """
+        return self._get_sub_prop("useAvroLogicalTypes")
+
+    @use_avro_logical_types.setter
+    def use_avro_logical_types(self, value):
+        self._set_sub_prop("useAvroLogicalTypes", bool(value))
+
+    @property
+    def write_disposition(self):
+        """Optional[google.cloud.bigquery.job.WriteDisposition]: Action that occurs if
+        the destination table already exists.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.write_disposition
+        """
+        return self._get_sub_prop("writeDisposition")
+
+    @write_disposition.setter
+    def write_disposition(self, value):
+        self._set_sub_prop("writeDisposition", value)
+
+    @property
+    def parquet_options(self):
+        """Optional[google.cloud.bigquery.format_options.ParquetOptions]: Additional
+            properties to set if ``sourceFormat`` is set to PARQUET.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.parquet_options
+        """
+        prop = self._get_sub_prop("parquetOptions")
+        if prop is not None:
+            prop = ParquetOptions.from_api_repr(prop)
+        return prop
+
+    @parquet_options.setter
+    def parquet_options(self, value):
+        if value is not None:
+            self._set_sub_prop("parquetOptions", value.to_api_repr())
+        else:
+            self._del_sub_prop("parquetOptions")
+
+    @property
+    def column_name_character_map(self) -> str:
+        """Optional[google.cloud.bigquery.job.ColumnNameCharacterMap]:
+        Character map supported for column names in CSV/Parquet loads. Defaults
+        to STRICT and can be overridden by Project Config Service. Using this
+        option with unsupported load formats will result in an error.
+
+        See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.column_name_character_map
+        """
+        return self._get_sub_prop(
+            "columnNameCharacterMap",
+            ColumnNameCharacterMap.COLUMN_NAME_CHARACTER_MAP_UNSPECIFIED,
+        )
+
+    @column_name_character_map.setter
+    def column_name_character_map(self, value: Optional[str]):
+        if value is None:
+            value = ColumnNameCharacterMap.COLUMN_NAME_CHARACTER_MAP_UNSPECIFIED
+        self._set_sub_prop("columnNameCharacterMap", value)
+
+    @property
+    def timestamp_target_precision(self) -> Optional[List[int]]:
+        """Optional[list[int]]: [Private Preview] Precisions (maximum number of
+        total digits in base 10) for seconds of TIMESTAMP types that are
+        allowed to the destination table for autodetection mode.
+
+        Available for the formats: CSV.
+
+        For the CSV Format, Possible values include:
+            None, [], or [6]: timestamp(6) for all auto detected TIMESTAMP
+            columns.
+            [6, 12]: timestamp(6) for all auto detected TIMESTAMP columns that
+            have less than 6 digits of subseconds. timestamp(12) for all auto
+            detected TIMESTAMP columns that have more than 6 digits of
+            subseconds.
+            [12]: timestamp(12) for all auto detected TIMESTAMP columns.
+
+        The order of the elements in this array is ignored. Inputs that have
+        higher precision than the highest target precision in this array will
+        be truncated.
+        """
+        return self._get_sub_prop("timestampTargetPrecision")
+
+    @timestamp_target_precision.setter
+    def timestamp_target_precision(self, value: Optional[List[int]]):
+        if value is not None:
+            self._set_sub_prop("timestampTargetPrecision", value)
+        else:
+            self._del_sub_prop("timestampTargetPrecision")
+
+
+class LoadJob(_AsyncJob):
+    """Asynchronous job for loading data into a table.
+
+    Can load from Google Cloud Storage URIs or from a file.
+
+    Args:
+        job_id (str): the job's ID
+
+        source_uris (Optional[Sequence[str]]):
+            URIs of one or more data files to be loaded.  See
+            https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.source_uris
+            for supported URI formats. Pass None for jobs that load from a file.
+
+        destination (google.cloud.bigquery.table.TableReference): reference to table into which data is to be loaded.
+
+        client (google.cloud.bigquery.client.Client):
+            A client which holds credentials and project configuration
+            for the dataset (which requires a project).
+    """
+
+    _JOB_TYPE = "load"
+    _CONFIG_CLASS = LoadJobConfig
+
+    def __init__(self, job_id, source_uris, destination, client, job_config=None):
+        super(LoadJob, self).__init__(job_id, client)
+
+        if job_config is not None:
+            self._properties["configuration"] = job_config._properties
+
+        if source_uris is not None:
+            _helpers._set_sub_prop(
+                self._properties, ["configuration", "load", "sourceUris"], source_uris
+            )
+
+        if destination is not None:
+            _helpers._set_sub_prop(
+                self._properties,
+                ["configuration", "load", "destinationTable"],
+                destination.to_api_repr(),
+            )
+
+    @property
+    def configuration(self) -> LoadJobConfig:
+        """The configuration for this load job."""
+        return typing.cast(LoadJobConfig, super().configuration)
+
+    @property
+    def destination(self):
+        """google.cloud.bigquery.table.TableReference: table where loaded rows are written
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.destination_table
+        """
+        dest_config = _helpers._get_sub_prop(
+            self._properties, ["configuration", "load", "destinationTable"]
+        )
+        return TableReference.from_api_repr(dest_config)
+
+    @property
+    def source_uris(self):
+        """Optional[Sequence[str]]: URIs of data files to be loaded. See
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad.FIELDS.source_uris
+        for supported URI formats. None for jobs that load from a file.
+        """
+        return _helpers._get_sub_prop(
+            self._properties, ["configuration", "load", "sourceUris"]
+        )
+
+    @property
+    def allow_jagged_rows(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.allow_jagged_rows`.
+        """
+        return self.configuration.allow_jagged_rows
+
+    @property
+    def allow_quoted_newlines(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.allow_quoted_newlines`.
+        """
+        return self.configuration.allow_quoted_newlines
+
+    @property
+    def autodetect(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.autodetect`.
+        """
+        return self.configuration.autodetect
+
+    @property
+    def connection_properties(self) -> List[ConnectionProperty]:
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.connection_properties`.
+
+        .. versionadded:: 3.7.0
+        """
+        return self.configuration.connection_properties
+
+    @property
+    def create_disposition(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.create_disposition`.
+        """
+        return self.configuration.create_disposition
+
+    @property
+    def create_session(self) -> Optional[bool]:
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.create_session`.
+
+        .. versionadded:: 3.7.0
+        """
+        return self.configuration.create_session
+
+    @property
+    def encoding(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.encoding`.
+        """
+        return self.configuration.encoding
+
+    @property
+    def field_delimiter(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.field_delimiter`.
+        """
+        return self.configuration.field_delimiter
+
+    @property
+    def ignore_unknown_values(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.ignore_unknown_values`.
+        """
+        return self.configuration.ignore_unknown_values
+
+    @property
+    def max_bad_records(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.max_bad_records`.
+        """
+        return self.configuration.max_bad_records
+
+    @property
+    def null_marker(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.null_marker`.
+        """
+        return self.configuration.null_marker
+
+    @property
+    def null_markers(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.null_markers`.
+        """
+        return self.configuration.null_markers
+
+    @property
+    def quote_character(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.quote_character`.
+        """
+        return self.configuration.quote_character
+
+    @property
+    def reference_file_schema_uri(self):
+        """See:
+        attr:`google.cloud.bigquery.job.LoadJobConfig.reference_file_schema_uri`.
+        """
+        return self.configuration.reference_file_schema_uri
+
+    @property
+    def skip_leading_rows(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.skip_leading_rows`.
+        """
+        return self.configuration.skip_leading_rows
+
+    @property
+    def source_format(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.source_format`.
+        """
+        return self.configuration.source_format
+
+    @property
+    def write_disposition(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.write_disposition`.
+        """
+        return self.configuration.write_disposition
+
+    @property
+    def schema(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.schema`.
+        """
+        return self.configuration.schema
+
+    @property
+    def destination_encryption_configuration(self):
+        """google.cloud.bigquery.encryption_configuration.EncryptionConfiguration: Custom
+        encryption configuration for the destination table.
+
+        Custom encryption configuration (e.g., Cloud KMS keys)
+        or :data:`None` if using default encryption.
+
+        See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.destination_encryption_configuration`.
+        """
+        return self.configuration.destination_encryption_configuration
+
+    @property
+    def destination_table_description(self):
+        """Optional[str] name given to destination table.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#DestinationTableProperties.FIELDS.description
+        """
+        return self.configuration.destination_table_description
+
+    @property
+    def destination_table_friendly_name(self):
+        """Optional[str] name given to destination table.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#DestinationTableProperties.FIELDS.friendly_name
+        """
+        return self.configuration.destination_table_friendly_name
+
+    @property
+    def range_partitioning(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.range_partitioning`.
+        """
+        return self.configuration.range_partitioning
+
+    @property
+    def time_partitioning(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.time_partitioning`.
+        """
+        return self.configuration.time_partitioning
+
+    @property
+    def use_avro_logical_types(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.use_avro_logical_types`.
+        """
+        return self.configuration.use_avro_logical_types
+
+    @property
+    def clustering_fields(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.clustering_fields`.
+        """
+        return self.configuration.clustering_fields
+
+    @property
+    def source_column_match(self) -> Optional[SourceColumnMatch]:
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.source_column_match`.
+        """
+        return self.configuration.source_column_match
+
+    @property
+    def date_format(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.date_format`.
+        """
+        return self.configuration.date_format
+
+    @property
+    def datetime_format(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.datetime_format`.
+        """
+        return self.configuration.datetime_format
+
+    @property
+    def time_zone(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.time_zone`.
+        """
+        return self.configuration.time_zone
+
+    @property
+    def time_format(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.time_format`.
+        """
+        return self.configuration.time_format
+
+    @property
+    def timestamp_format(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.timestamp_format`.
+        """
+        return self.configuration.timestamp_format
+
+    @property
+    def schema_update_options(self):
+        """See
+        :attr:`google.cloud.bigquery.job.LoadJobConfig.schema_update_options`.
+        """
+        return self.configuration.schema_update_options
+
+    @property
+    def input_file_bytes(self):
+        """Count of bytes loaded from source files.
+
+        Returns:
+            Optional[int]: the count (None until set from the server).
+
+        Raises:
+            ValueError: for invalid value types.
+        """
+        return _helpers._int_or_none(
+            _helpers._get_sub_prop(
+                self._properties, ["statistics", "load", "inputFileBytes"]
+            )
+        )
+
+    @property
+    def input_files(self):
+        """Count of source files.
+
+        Returns:
+            Optional[int]: the count (None until set from the server).
+        """
+        return _helpers._int_or_none(
+            _helpers._get_sub_prop(
+                self._properties, ["statistics", "load", "inputFiles"]
+            )
+        )
+
+    @property
+    def output_bytes(self):
+        """Count of bytes saved to destination table.
+
+        Returns:
+            Optional[int]: the count (None until set from the server).
+        """
+        return _helpers._int_or_none(
+            _helpers._get_sub_prop(
+                self._properties, ["statistics", "load", "outputBytes"]
+            )
+        )
+
+    @property
+    def output_rows(self):
+        """Count of rows saved to destination table.
+
+        Returns:
+            Optional[int]: the count (None until set from the server).
+        """
+        return _helpers._int_or_none(
+            _helpers._get_sub_prop(
+                self._properties, ["statistics", "load", "outputRows"]
+            )
+        )
+
+    def to_api_repr(self):
+        """Generate a resource for :meth:`_begin`."""
+        # Exclude statistics, if set.
+        return {
+            "jobReference": self._properties["jobReference"],
+            "configuration": self._properties["configuration"],
+        }
+
+    @classmethod
+    def from_api_repr(cls, resource: dict, client) -> "LoadJob":
+        """Factory:  construct a job given its API representation
+
+        .. note::
+
+           This method assumes that the project found in the resource matches
+           the client's project.
+
+        Args:
+            resource (Dict): dataset job representation returned from the API
+
+            client (google.cloud.bigquery.client.Client):
+                Client which holds credentials and project
+                configuration for the dataset.
+
+        Returns:
+            google.cloud.bigquery.job.LoadJob: Job parsed from ``resource``.
+        """
+        cls._check_resource_config(resource)
+        job_ref = _JobReference._from_api_repr(resource["jobReference"])
+        job = cls(job_ref, None, None, client)
+        job._set_properties(resource)
+        return job

data/conda_envs/evalclaw/lib/python3.11/site-packages/google/cloud/bigquery/magics/__init__.py

@@ -0,0 +1,20 @@
+# 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 google.cloud.bigquery.magics.magics import context
+
+
+# For backwards compatibility we need to make the context available in the path
+# google.cloud.bigquery.magics.context
+__all__ = ("context",)