google-cloud-bigquery 3.40.1__tar.gz → 3.41.0__tar.gz

{google_cloud_bigquery-3.40.1/google_cloud_bigquery.egg-info → google_cloud_bigquery-3.41.0}/PKG-INFO

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigquery
-Version: 3.40.1
+Version: 3.41.0
 Summary: Google BigQuery API client library
 Author-email: Google LLC <googleapis-packages@google.com>
-License-Expression: Apache-2.0
+License: Apache 2.0
 Project-URL: Repository, https://github.com/googleapis/python-bigquery
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -17,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet
-Requires-Python: >=3.9
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: google-api-core[grpc]<3.0.0,>=2.11.1

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/google/cloud/bigquery/dbapi/cursor.py

@@ -213,6 +213,7 @@ class Cursor(object):
                     formatted_operation,
                     job_config=job_config,
                     job_id=job_id,
+                    job_retry=None,
                 ).result(
                     page_size=self.arraysize,
                 )

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/google/cloud/bigquery/job/query.py

@@ -50,7 +50,7 @@ from google.cloud.bigquery.schema import SchemaField
 from google.cloud.bigquery.table import _EmptyRowIterator
 from google.cloud.bigquery.table import RangePartitioning
 from google.cloud.bigquery.table import _table_arg_to_table_ref
-from google.cloud.bigquery.table import TableReference
+from google.cloud.bigquery.table import TableReference, PropertyGraphReference
 from google.cloud.bigquery.table import TimePartitioning
 from google.cloud.bigquery._tqdm_helpers import wait_for_query
 
@@ -1332,6 +1332,30 @@ class QueryJob(_AsyncJob):
 
         return tables
 
+    @property
+    def referenced_property_graphs(self):
+        """Return referenced property graphs from job statistics, if present.
+
+        See:
+        https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobStatistics2.FIELDS.referenced_property_graphs
+
+        Returns:
+            List[google.cloud.bigquery.table.PropertyGraphReference]:
+                mappings describing the property graphs, or an empty list
+                if the query has not yet completed.
+        """
+        property_graphs = []
+
+        for pg in self._job_statistics().get("referencedPropertyGraphs", ()):
+            property_graphs.append(
+                PropertyGraphReference(
+                    DatasetReference(pg["projectId"], pg["datasetId"]),
+                    pg["propertyGraphId"],
+                )
+            )
+
+        return property_graphs
+
     @property
     def undeclared_query_parameters(self):
         """Return undeclared query parameters from job statistics, if present.

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/google/cloud/bigquery/table.py

@@ -138,7 +138,7 @@ def _reference_getter(table):
 
 
 def _view_use_legacy_sql_getter(
-    table: Union["Table", "TableListItem"]
+    table: Union["Table", "TableListItem"],
 ) -> Optional[bool]:
     """bool: Specifies whether to execute the view with Legacy or Standard SQL.
 
@@ -359,6 +359,98 @@ class TableReference(_TableBase):
         return f"TableReference({dataset_ref!r}, '{self.table_id}')"
 
 
+class PropertyGraphReference:
+    """PropertyGraphReferences are pointers to property graphs.
+
+    Args:
+        dataset_ref: A pointer to the dataset
+        property_graph_id: The ID of the property graph
+    """
+
+    _PROPERTY_TO_API_FIELD = {
+        "dataset_id": "datasetId",
+        "project": "projectId",
+        "property_graph_id": "propertyGraphId",
+    }
+
+    def __init__(self, dataset_ref: "DatasetReference", property_graph_id: str):
+        self._properties: Dict[str, Any] = {}
+
+        _helpers._set_sub_prop(
+            self._properties,
+            self._PROPERTY_TO_API_FIELD["project"],
+            dataset_ref.project,
+        )
+        _helpers._set_sub_prop(
+            self._properties,
+            self._PROPERTY_TO_API_FIELD["dataset_id"],
+            dataset_ref.dataset_id,
+        )
+        _helpers._set_sub_prop(
+            self._properties,
+            self._PROPERTY_TO_API_FIELD["property_graph_id"],
+            property_graph_id,
+        )
+
+    @property
+    def project(self) -> str:
+        """str: Project bound to the property graph."""
+        return _helpers._get_sub_prop(
+            self._properties, self._PROPERTY_TO_API_FIELD["project"]
+        )
+
+    @property
+    def dataset_id(self) -> str:
+        """str: ID of dataset containing the property graph."""
+        return _helpers._get_sub_prop(
+            self._properties, self._PROPERTY_TO_API_FIELD["dataset_id"]
+        )
+
+    @property
+    def property_graph_id(self) -> str:
+        """str: The property graph ID."""
+        return _helpers._get_sub_prop(
+            self._properties, self._PROPERTY_TO_API_FIELD["property_graph_id"]
+        )
+
+    @classmethod
+    def from_api_repr(cls, resource: dict) -> "PropertyGraphReference":
+        """Factory: construct a property graph reference given its API representation."""
+        from google.cloud.bigquery.dataset import DatasetReference
+
+        project = resource["projectId"]
+        dataset_id = resource["datasetId"]
+        property_graph_id = resource["propertyGraphId"]
+
+        return cls(DatasetReference(project, dataset_id), property_graph_id)
+
+    def to_api_repr(self) -> dict:
+        """Construct the API resource representation of this property graph reference."""
+        return copy.deepcopy(self._properties)
+
+    def __str__(self):
+        return f"{self.project}.{self.dataset_id}.{self.property_graph_id}"
+
+    def __repr__(self):
+        from google.cloud.bigquery.dataset import DatasetReference
+
+        dataset_ref = DatasetReference(self.project, self.dataset_id)
+        return f"PropertyGraphReference({dataset_ref!r}, '{self.property_graph_id}')"
+
+    def __eq__(self, other):
+        if isinstance(other, PropertyGraphReference):
+            return (
+                self.project == other.project
+                and self.dataset_id == other.dataset_id
+                and self.property_graph_id == other.property_graph_id
+            )
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash((self.project, self.dataset_id, self.property_graph_id))
+
+
 class Table(_TableBase):
     """Tables represent a set of rows whose values correspond to a schema.
 

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/google/cloud/bigquery/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "3.40.1"
+__version__ = "3.41.0"

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0/google_cloud_bigquery.egg-info}/PKG-INFO

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigquery
-Version: 3.40.1
+Version: 3.41.0
 Summary: Google BigQuery API client library
 Author-email: Google LLC <googleapis-packages@google.com>
-License-Expression: Apache-2.0
+License: Apache 2.0
 Project-URL: Repository, https://github.com/googleapis/python-bigquery
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -17,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet
-Requires-Python: >=3.9
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: google-api-core[grpc]<3.0.0,>=2.11.1

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/pyproject.toml

@@ -19,9 +19,8 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "google-cloud-bigquery"
 authors = [{ name = "Google LLC", email = "googleapis-packages@google.com" }]
-license = "Apache-2.0"
-license-files = ["LICENSE"]
-requires-python = ">=3.9"
+license = { text = "Apache 2.0" }
+requires-python = ">=3.8"
 description = "Google BigQuery API client library"
 readme = "README.rst"
 classifiers = [
@@ -33,6 +32,7 @@ classifiers = [
   "Intended Audience :: Developers",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/setup.py

@@ -14,5 +14,4 @@
 
 import setuptools  # type: ignore
 
-
 setuptools.setup()

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/system/conftest.py

@@ -175,15 +175,22 @@ def scalars_table_csv(
 def scalars_table_pico(
     bigquery_client: bigquery.Client, project_id: str, dataset_id: str
 ):
-    full_table_id = load_scalars_table(
-        bigquery_client,
-        project_id,
-        dataset_id,
-        data_path="pico.csv",
-        source_format=enums.SourceFormat.CSV,
-        schema_source="pico_schema.json",
-        timestamp_target_precision=[12],
-    )
+    from google.api_core import exceptions
+
+    try:
+        full_table_id = load_scalars_table(
+            bigquery_client,
+            project_id,
+            dataset_id,
+            data_path="pico.csv",
+            source_format=enums.SourceFormat.CSV,
+            schema_source="pico_schema.json",
+            timestamp_target_precision=[12],
+        )
+    except exceptions.BadRequest as exc:
+        if "picosecond precision" in str(exc):
+            pytest.skip("Picosecond precision not supported in this environment")
+        raise exc
     yield full_table_id
     bigquery_client.delete_table(full_table_id, not_found_ok=True)
 

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/system/test_client.py

@@ -234,7 +234,7 @@ class TestBigQuery(unittest.TestCase):
 
     def test_close_releases_open_sockets(self):
         current_process = psutil.Process()
-        conn_count_start = len(current_process.connections())
+        conn_count_start = len(current_process.net_connections())
 
         client = Config.CLIENT
         client.query(
@@ -250,7 +250,7 @@ class TestBigQuery(unittest.TestCase):
 
         client.close()
 
-        conn_count_end = len(current_process.connections())
+        conn_count_end = len(current_process.net_connections())
         self.assertLessEqual(conn_count_end, conn_count_start)
 
     def test_create_dataset(self):
@@ -601,7 +601,7 @@ class TestBigQuery(unittest.TestCase):
         # Insert rows into the created table to verify default values are populated
         # when value is not provided
         NOW_SECONDS = 1448911495.484366
-        NOW = datetime.datetime.utcfromtimestamp(NOW_SECONDS).replace(tzinfo=UTC)
+        NOW = datetime.datetime.fromtimestamp(NOW_SECONDS, datetime.timezone.utc)
 
         # Rows to insert. Row #1 will have default `TIMESTAMP` defaultValueExpression CURRENT_TIME
         # Row #2 will have default `STRING` defaultValueExpression "'FOO"
@@ -647,7 +647,13 @@ class TestBigQuery(unittest.TestCase):
         table_arg = Table(dataset.table(table_id), schema=SCHEMA_PICOSECOND)
         self.assertFalse(_table_exists(table_arg))
 
-        table = helpers.retry_403(Config.CLIENT.create_table)(table_arg)
+        try:
+            table = helpers.retry_403(Config.CLIENT.create_table)(table_arg)
+        except BadRequest as exc:
+            if "picosecond precision" in str(exc):
+                self.skipTest("Picosecond precision not supported in this environment")
+            raise exc
+
         self.to_delete.insert(0, table)
 
         self.assertTrue(_table_exists(table))
@@ -1056,7 +1062,7 @@ class TestBigQuery(unittest.TestCase):
 
     def test_insert_rows_then_dump_table(self):
         NOW_SECONDS = 1448911495.484366
-        NOW = datetime.datetime.utcfromtimestamp(NOW_SECONDS).replace(tzinfo=UTC)
+        NOW = datetime.datetime.fromtimestamp(NOW_SECONDS, datetime.timezone.utc)
         ROWS = [
             ("Phred Phlyntstone", 32, NOW),
             ("Bharney Rhubble", 33, NOW + datetime.timedelta(seconds=10)),
@@ -1304,9 +1310,14 @@ class TestBigQuery(unittest.TestCase):
 
         table_schema = Config.CLIENT.schema_from_json(DATA_PATH / "pico_schema.json")
         # create the table before loading so that the column order is predictable
-        table = helpers.retry_403(Config.CLIENT.create_table)(
-            Table(table_id, schema=table_schema)
-        )
+        try:
+            table = helpers.retry_403(Config.CLIENT.create_table)(
+                Table(table_id, schema=table_schema)
+            )
+        except BadRequest as exc:
+            if "picosecond precision" in str(exc):
+                self.skipTest("Picosecond precision not supported in this environment")
+            raise exc
         self.to_delete.insert(0, table)
 
         # do not pass an explicit job config to trigger automatic schema detection
@@ -1844,7 +1855,9 @@ class TestBigQuery(unittest.TestCase):
         job_config.query_parameters = [PARAM]
 
         with self.assertRaises(BadRequest):
-            Config.CLIENT.query(QUERY, job_id=JOB_ID, job_config=job_config).result()
+            Config.CLIENT.query(
+                QUERY, job_id=JOB_ID, job_config=job_config, job_retry=None
+            ).result()
 
         job = Config.CLIENT.get_job(JOB_ID)
 
@@ -2137,7 +2150,7 @@ class TestBigQuery(unittest.TestCase):
     def test_dbapi_connection_does_not_leak_sockets(self):
         pytest.importorskip("google.cloud.bigquery_storage")
         current_process = psutil.Process()
-        conn_count_start = len(current_process.connections())
+        conn_count_start = len(current_process.net_connections())
 
         # Provide no explicit clients, so that the connection will create and own them.
         connection = dbapi.connect()
@@ -2155,7 +2168,7 @@ class TestBigQuery(unittest.TestCase):
         self.assertEqual(len(rows), 100000)
 
         connection.close()
-        conn_count_end = len(current_process.connections())
+        conn_count_end = len(current_process.net_connections())
         self.assertLessEqual(conn_count_end, conn_count_start)
 
     def _load_table_for_dml(self, rows, dataset_id, table_id):

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/system/test_magics.py

@@ -48,7 +48,7 @@ def ipython_interactive(ipython):
 def test_bigquery_magic(ipython_interactive):
     ip = IPython.get_ipython()
     current_process = psutil.Process()
-    conn_count_start = len(current_process.connections())
+    conn_count_start = len(current_process.net_connections())
 
     # Deprecated, but should still work in google-cloud-bigquery 3.x.
     with pytest.warns(FutureWarning, match="bigquery_magics"):
@@ -68,7 +68,7 @@ def test_bigquery_magic(ipython_interactive):
     with io.capture_output() as captured:
         result = ip.run_cell_magic("bigquery", "--use_rest_api", sql)
 
-    conn_count_end = len(current_process.connections())
+    conn_count_end = len(current_process.net_connections())
 
     lines = re.split("\n|\r", captured.stdout)
     # Removes blanks & terminal code (result of display clearing)

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/system/test_pandas.py

@@ -1155,7 +1155,7 @@ def test_list_rows_nullable_scalars_extreme_dtypes(
 
     # pandas uses Python string and bytes objects.
     assert df.dtypes["bytes_col"].name == "object"
-    assert df.dtypes["string_col"].name == "object"
+    assert df.dtypes["string_col"].name in {"object", "string", "str", "O"}
 
 
 @pytest.mark.parametrize(

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/system/test_query.py

@@ -550,11 +550,18 @@ def test_session(bigquery_client: bigquery.Client, query_api_method: str):
 
 
 def test_query_picosecond(bigquery_client: bigquery.Client):
-    job = bigquery_client.query(
-        "SELECT CAST('2025-10-20' AS TIMESTAMP(12));",
-        api_method="QUERY",
-        timestamp_precision=enums.TimestampPrecision.PICOSECOND,
-    )
+    try:
+        job = bigquery_client.query(
+            "SELECT CAST('2025-10-20' AS TIMESTAMP(12));",
+            api_method="QUERY",
+            timestamp_precision=enums.TimestampPrecision.PICOSECOND,
+        )
+    except exceptions.BadRequest as exc:
+        if "timestamp_output_format" in str(exc):
+            pytest.skip(
+                "Timestamp output format not supported or parameter invalid for this environment"
+            )
+        raise exc
 
     result = job.result()
     rows = list(result)

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/unit/job/test_async_job_retry.py

@@ -26,8 +26,6 @@ JOB_ID = "test-job-id"
 
 
 def test_cancel_w_custom_retry(global_time_lock):
-    from google.cloud.bigquery.retry import DEFAULT_RETRY
-
     api_path = "/projects/{}/jobs/{}/cancel".format(PROJECT, JOB_ID)
     resource = {
         "jobReference": {
@@ -49,8 +47,11 @@ def test_cancel_w_custom_retry(global_time_lock):
         google.cloud.bigquery.job._JobReference(JOB_ID, PROJECT, "EU"), client
     )
 
-    retry = DEFAULT_RETRY.with_deadline(1).with_predicate(
-        lambda exc: isinstance(exc, ValueError)
+    retry = google.api_core.retry.Retry(
+        predicate=lambda exc: isinstance(exc, ValueError),
+        initial=0.01,
+        maximum=0.01,
+        deadline=1.0,
     )
 
     with mock.patch(

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/unit/job/test_query.py

@@ -680,6 +680,55 @@ class TestQueryJob(_Base):
         self.assertEqual(remote.dataset_id, "other-dataset")
         self.assertEqual(remote.project, "other-project-123")
 
+    def test_referenced_property_graphs(self):
+        from google.cloud.bigquery.table import PropertyGraphReference
+
+        ref_pg_resource = [
+            {
+                "projectId": self.PROJECT,
+                "datasetId": "dataset",
+                "propertyGraphId": "pg1",
+            },
+            {
+                "projectId": self.PROJECT,
+                "datasetId": "dataset",
+                "propertyGraphId": "pg2",
+            },
+            {
+                "projectId": "other-project-123",
+                "datasetId": "other-dataset",
+                "propertyGraphId": "other-pg",
+            },
+        ]
+        client = _make_client(project=self.PROJECT)
+        job = self._make_one(self.JOB_ID, self.QUERY, client)
+        self.assertEqual(job.referenced_property_graphs, [])
+
+        statistics = job._properties["statistics"] = {}
+        self.assertEqual(job.referenced_property_graphs, [])
+
+        query_stats = statistics["query"] = {}
+        self.assertEqual(job.referenced_property_graphs, [])
+
+        query_stats["referencedPropertyGraphs"] = ref_pg_resource
+
+        pg1, pg2, remote = job.referenced_property_graphs
+
+        self.assertIsInstance(pg1, PropertyGraphReference)
+        self.assertEqual(pg1.property_graph_id, "pg1")
+        self.assertEqual(pg1.dataset_id, "dataset")
+        self.assertEqual(pg1.project, self.PROJECT)
+
+        self.assertIsInstance(pg2, PropertyGraphReference)
+        self.assertEqual(pg2.property_graph_id, "pg2")
+        self.assertEqual(pg2.dataset_id, "dataset")
+        self.assertEqual(pg2.project, self.PROJECT)
+
+        self.assertIsInstance(remote, PropertyGraphReference)
+        self.assertEqual(remote.property_graph_id, "other-pg")
+        self.assertEqual(remote.dataset_id, "other-dataset")
+        self.assertEqual(remote.project, "other-project-123")
+
     def test_timeline(self):
         timeline_resource = [
             {

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/unit/job/test_query_pandas.py

@@ -707,11 +707,11 @@ def test_to_dataframe_column_dtypes():
     assert df.seconds.dtype.name == "Int64"
     assert df.miles.dtype.name == "float64"
     assert df.km.dtype.name == "float16"
-    assert df.payment_type.dtype.name == "object"
+    assert df.payment_type.dtype.name in {"object", "string", "str", "O"}
     assert df.complete.dtype.name == "boolean"
     assert df.date.dtype.name == "dbdate"
 
-    if pandas.__version__.startswith("2."):
+    if pandas.__version__.startswith(("2.", "3.")):
         assert df.start_timestamp.dtype.name == "datetime64[us, UTC]"
     else:
         assert df.start_timestamp.dtype.name == "datetime64[ns, UTC]"

{google_cloud_bigquery-3.40.1 → google_cloud_bigquery-3.41.0}/tests/unit/test__pandas_helpers.py

@@ -851,12 +851,16 @@ def test_list_columns_and_indexes_without_named_index(module_under_test):
     dataframe = pandas.DataFrame(df_data)
 
     columns_and_indexes = module_under_test.list_columns_and_indexes(dataframe)
-    expected = [
+    expected_stable_types = [
         ("a_series", pandas.api.types.pandas_dtype("int64")),
         ("b_series", pandas.api.types.pandas_dtype("float64")),
-        ("c_series", pandas.api.types.pandas_dtype("object")),
     ]
-    assert columns_and_indexes == expected
+    assert columns_and_indexes[:-1] == expected_stable_types
+
+    # The last column is string/object, which varies by pandas/pyarrow version
+    string_col_name, string_col_dtype = columns_and_indexes[-1]
+    assert string_col_name == "c_series"
+    assert string_col_dtype.name in {"object", "string", "str", "O"}
 
 
 @pytest.mark.skipif(pandas is None, reason="Requires `pandas`")
@@ -878,12 +882,16 @@ def test_list_columns_and_indexes_with_named_index_same_as_column_name(
     )
 
     columns_and_indexes = module_under_test.list_columns_and_indexes(dataframe)
-    expected = [
+    expected_stable_types = [
         ("a_series", pandas.api.types.pandas_dtype("int64")),
         ("b_series", pandas.api.types.pandas_dtype("float64")),
-        ("c_series", pandas.api.types.pandas_dtype("object")),
     ]
-    assert columns_and_indexes == expected
+    assert columns_and_indexes[:-1] == expected_stable_types
+
+    # The last column is string/object, which varies by pandas/pyarrow version
+    string_col_name, string_col_dtype = columns_and_indexes[-1]
+    assert string_col_name == "c_series"
+    assert string_col_dtype.name in {"object", "string", "str", "O"}
 
 
 @pytest.mark.skipif(pandas is None, reason="Requires `pandas`")
@@ -986,13 +994,19 @@ def test_list_columns_and_indexes_with_named_index(module_under_test):
     )
 
     columns_and_indexes = module_under_test.list_columns_and_indexes(dataframe)
-    expected = [
+
+    # First few columns have stable types (int, float)
+    expected_stable_types = [
         ("a_index", pandas.api.types.pandas_dtype("int64")),
         ("a_series", pandas.api.types.pandas_dtype("int64")),
         ("b_series", pandas.api.types.pandas_dtype("float64")),
-        ("c_series", pandas.api.types.pandas_dtype("object")),
     ]
-    assert columns_and_indexes == expected
+    assert columns_and_indexes[:-1] == expected_stable_types
+
+    # The last column is string/object, which varies by pandas/pyarrow version
+    string_col_name, string_col_dtype = columns_and_indexes[-1]
+    assert string_col_name == "c_series"
+    assert string_col_dtype.name in {"object", "string", "str", "O"}
 
 
 @pytest.mark.skipif(pandas is None, reason="Requires `pandas`")
@@ -1019,14 +1033,20 @@ def test_list_columns_and_indexes_with_multiindex(module_under_test):
     )
 
     columns_and_indexes = module_under_test.list_columns_and_indexes(dataframe)
-    expected = [
+
+    # First few columns have stable types (int, float)
+    expected_stable_types = [
         ("a_index", pandas.api.types.pandas_dtype("int64")),
         ("c_index", pandas.api.types.pandas_dtype("int64")),
         ("a_series", pandas.api.types.pandas_dtype("int64")),
         ("b_series", pandas.api.types.pandas_dtype("float64")),
-        ("c_series", pandas.api.types.pandas_dtype("object")),
     ]
-    assert columns_and_indexes == expected
+    assert columns_and_indexes[:-1] == expected_stable_types
+
+    # The last column is string/object, which varies by pandas/pyarrow version
+    string_col_name, string_col_dtype = columns_and_indexes[-1]
+    assert string_col_name == "c_series"
+    assert string_col_dtype.name in {"object", "string", "str", "O"}
 
 
 @pytest.mark.skipif(pandas is None, reason="Requires `pandas`")
@@ -1345,15 +1365,21 @@ def test_dataframe_to_bq_schema_w_multiindex(module_under_test, monkeypatch):
     with pytest.warns(FutureWarning, match="pandas-gbq"):
         returned_schema = module_under_test.dataframe_to_bq_schema(dataframe, [])
 
-    expected_schema = (
-        schema.SchemaField("str_index", "STRING", "NULLABLE"),
-        schema.SchemaField("int_index", "INTEGER", "NULLABLE"),
-        schema.SchemaField("dt_index", "DATETIME", "NULLABLE"),
-        schema.SchemaField("str_column", "STRING", "NULLABLE"),
-        schema.SchemaField("int_column", "INTEGER", "NULLABLE"),
-        schema.SchemaField("bool_column", "BOOLEAN", "NULLABLE"),
+    # dt_index can be DATETIME or TIMESTAMP depending on pandas version/environment
+    # We check the stable columns first
+    assert returned_schema[0] == schema.SchemaField("str_index", "STRING", "NULLABLE")
+    assert returned_schema[1] == schema.SchemaField("int_index", "INTEGER", "NULLABLE")
+
+    # Flexible check for dt_index
+    assert returned_schema[2].name == "dt_index"
+    assert returned_schema[2].field_type in {"DATETIME", "TIMESTAMP"}
+    assert returned_schema[2].mode == "NULLABLE"
+
+    assert returned_schema[3] == schema.SchemaField("str_column", "STRING", "NULLABLE")
+    assert returned_schema[4] == schema.SchemaField("int_column", "INTEGER", "NULLABLE")
+    assert returned_schema[5] == schema.SchemaField(
+        "bool_column", "BOOLEAN", "NULLABLE"
     )
-    assert returned_schema == expected_schema
 
 
 @pytest.mark.skipif(pandas is None, reason="Requires `pandas`")