style: apply ruff formatting and fix version helper caching leak

Author: shuoweil

packages/google-cloud-bigquery/google/cloud/bigquery/_versions_helpers.py

@@ -263,9 +263,7 @@ def installed_version(self) -> packaging.version.Version:
         try:
             import pandas_gbq  # type: ignore
 
-            return packaging.version.parse(
-                getattr(pandas_gbq, "__version__", "0.0.0")
-            )
+            return packaging.version.parse(getattr(pandas_gbq, "__version__", "0.0.0"))
         except Exception:
             return packaging.version.parse("0.0.0")
 

packages/google-cloud-bigquery/google/cloud/bigquery/magics/magics.py

@@ -496,8 +496,9 @@ def _cell_magic(line, query):
         raise rebranded_error from exc
     except lap.exceptions.ParseError as exc:
         rebranded_error = ValueError(
-            "Unrecognized input, are option values correct? "
-            "Error details: {}".format(exc.args[0])
+            "Unrecognized input, are option values correct? Error details: {}".format(
+                exc.args[0]
+            )
         )
         raise rebranded_error from exc
 

packages/google-cloud-bigquery/google/cloud/bigquery/table.py

@@ -542,9 +542,9 @@ def biglake_configuration(self, value):
         api_repr = value
         if value is not None:
             api_repr = value.to_api_repr()
-        self._properties[
-            self._PROPERTY_TO_API_FIELD["biglake_configuration"]
-        ] = api_repr
+        self._properties[self._PROPERTY_TO_API_FIELD["biglake_configuration"]] = (
+            api_repr
+        )
 
     @property
     def require_partition_filter(self):
@@ -558,9 +558,9 @@ def require_partition_filter(self):
 
     @require_partition_filter.setter
     def require_partition_filter(self, value):
-        self._properties[
-            self._PROPERTY_TO_API_FIELD["require_partition_filter"]
-        ] = value
+        self._properties[self._PROPERTY_TO_API_FIELD["require_partition_filter"]] = (
+            value
+        )
 
     @property
     def schema(self):
@@ -658,9 +658,9 @@ def encryption_configuration(self, value):
         api_repr = value
         if value is not None:
             api_repr = value.to_api_repr()
-        self._properties[
-            self._PROPERTY_TO_API_FIELD["encryption_configuration"]
-        ] = api_repr
+        self._properties[self._PROPERTY_TO_API_FIELD["encryption_configuration"]] = (
+            api_repr
+        )
 
     @property
     def created(self):
@@ -799,7 +799,7 @@ def time_partitioning(self, value):
             api_repr = value.to_api_repr()
         elif value is not None:
             raise ValueError(
-                "value must be google.cloud.bigquery.table.TimePartitioning " "or None"
+                "value must be google.cloud.bigquery.table.TimePartitioning or None"
             )
         self._properties[self._PROPERTY_TO_API_FIELD["time_partitioning"]] = api_repr
 
@@ -935,9 +935,9 @@ def expires(self, value):
         if not isinstance(value, datetime.datetime) and value is not None:
             raise ValueError("Pass a datetime, or None")
         value_ms = google.cloud._helpers._millis_from_datetime(value)
-        self._properties[
-            self._PROPERTY_TO_API_FIELD["expires"]
-        ] = _helpers._str_or_none(value_ms)
+        self._properties[self._PROPERTY_TO_API_FIELD["expires"]] = (
+            _helpers._str_or_none(value_ms)
+        )
 
     @property
     def friendly_name(self):
@@ -1133,9 +1133,9 @@ def external_data_configuration(self, value):
         api_repr = value
         if value is not None:
             api_repr = value.to_api_repr()
-        self._properties[
-            self._PROPERTY_TO_API_FIELD["external_data_configuration"]
-        ] = api_repr
+        self._properties[self._PROPERTY_TO_API_FIELD["external_data_configuration"]] = (
+            api_repr
+        )
 
     @property
     def snapshot_definition(self) -> Optional["SnapshotDefinition"]:
@@ -3038,8 +3038,7 @@ def to_geodataframe(
         )
         if not geography_columns:
             raise TypeError(
-                "There must be at least one GEOGRAPHY column"
-                " to create a GeoDataFrame"
+                "There must be at least one GEOGRAPHY column to create a GeoDataFrame"
             )
 
         if geography_column:

packages/google-cloud-bigquery/tests/unit/test__pyarrow_helpers.py

@@ -35,8 +35,7 @@ def test_bq_to_arrow_scalars(module_under_test):
         # but we'd like this to map as closely to the BQ Storage API as
         # possible, which uses the string() dtype, as JSON support in Arrow
         # predates JSON support in BigQuery by several years.
-        module_under_test.bq_to_arrow_scalars("JSON")()
-        == pyarrow.string()
+        module_under_test.bq_to_arrow_scalars("JSON")() == pyarrow.string()
     )
     assert module_under_test.bq_to_arrow_scalars("UNKNOWN_TYPE") is None
 

packages/google-cloud-bigquery/tests/unit/test_magics.py

@@ -686,9 +686,11 @@ def test_bigquery_magic_with_bqstorage_from_argument(
         google.cloud.bigquery.job.QueryJob, instance=True
     )
     query_job_mock.to_dataframe.return_value = result
-    with run_query_patch as run_query_mock, (
-        bqstorage_client_patch
-    ), warnings.catch_warnings(record=True) as warned:
+    with (
+        run_query_patch as run_query_mock,
+        bqstorage_client_patch,
+        warnings.catch_warnings(record=True) as warned,
+    ):
         run_query_mock.return_value = query_job_mock
 
         return_value = ip.run_cell_magic("bigquery", "--use_bqstorage_api", sql)
@@ -854,11 +856,12 @@ def test_bigquery_magic_w_max_results_query_job_results_fails(monkeypatch):
     )
     query_job_mock.result.side_effect = [[], OSError]
 
-    with pytest.raises(
-        OSError
-    ), client_query_patch as client_query_mock, (
-        default_patch
-    ), close_transports_patch as close_transports:
+    with (
+        pytest.raises(OSError),
+        client_query_patch as client_query_mock,
+        default_patch,
+        close_transports_patch as close_transports,
+    ):
         client_query_mock.return_value = query_job_mock
         ip.run_cell_magic("bigquery", "--max_results=5", sql)
 
@@ -1977,9 +1980,10 @@ def test_bigquery_magic_nonexisting_query_variable(monkeypatch):
     ip.user_ns.pop("custom_query", None)  # Make sure the variable does NOT exist.
     cell_body = "$custom_query"  # Referring to a non-existing variable name.
 
-    with pytest.raises(
-        NameError, match=r".*custom_query does not exist.*"
-    ), run_query_patch as run_query_mock:
+    with (
+        pytest.raises(NameError, match=r".*custom_query does not exist.*"),
+        run_query_patch as run_query_mock,
+    ):
         ip.run_cell_magic("bigquery", "", cell_body)
 
     run_query_mock.assert_not_called()
@@ -2000,9 +2004,10 @@ def test_bigquery_magic_empty_query_variable_name(monkeypatch):
     )
     cell_body = "$"  # Not referring to any variable (name omitted).
 
-    with pytest.raises(
-        NameError, match=r"(?i).*missing query variable name.*"
-    ), run_query_patch as run_query_mock:
+    with (
+        pytest.raises(NameError, match=r"(?i).*missing query variable name.*"),
+        run_query_patch as run_query_mock,
+    ):
         ip.run_cell_magic("bigquery", "", cell_body)
 
     run_query_mock.assert_not_called()
@@ -2028,9 +2033,10 @@ def test_bigquery_magic_query_variable_non_string(ipython_ns_cleanup, monkeypatc
     ip.user_ns["custom_query"] = object()
     cell_body = "$custom_query"  # Referring to a non-string variable.
 
-    with pytest.raises(
-        TypeError, match=r".*must be a string or a bytes-like.*"
-    ), run_query_patch as run_query_mock:
+    with (
+        pytest.raises(TypeError, match=r".*must be a string or a bytes-like.*"),
+        run_query_patch as run_query_mock,
+    ):
         ip.run_cell_magic("bigquery", "", cell_body)
 
     run_query_mock.assert_not_called()
@@ -2195,9 +2201,11 @@ def test_bigquery_magic_create_dataset_fails(monkeypatch):
         autospec=True,
     )
 
-    with pytest.raises(
-        OSError
-    ), create_dataset_if_necessary_patch, close_transports_patch as close_transports:
+    with (
+        pytest.raises(OSError),
+        create_dataset_if_necessary_patch,
+        close_transports_patch as close_transports,
+    ):
         ip.run_cell_magic(
             "bigquery",
             "--destination_table dataset_id.table_id",

packages/google-cloud-bigquery/tests/unit/test_table.py

@@ -376,9 +376,7 @@ def test_from_api_repr(self):
     def test___repr__(self):
         dataset = DatasetReference("project1", "dataset1")
         table1 = self._make_one(dataset, "table1")
-        expected = (
-            "TableReference(DatasetReference('project1', 'dataset1'), " "'table1')"
-        )
+        expected = "TableReference(DatasetReference('project1', 'dataset1'), 'table1')"
         self.assertEqual(repr(table1), expected)
 
     def test___str__(self):
@@ -1831,9 +1829,7 @@ def test___repr__(self):
         dataset = DatasetReference("project1", "dataset1")
         table1 = self._make_one(TableReference(dataset, "table1"))
         expected = (
-            "Table(TableReference("
-            "DatasetReference('project1', 'dataset1'), "
-            "'table1'))"
+            "Table(TableReference(DatasetReference('project1', 'dataset1'), 'table1'))"
         )
         self.assertEqual(repr(table1), expected)
 
@@ -2873,7 +2869,8 @@ def test__should_use_bqstorage_returns_true_if_no_cached_results(self):
 
     def test__should_use_bqstorage_returns_false_if_page_token_set(self):
         iterator = self._make_one(
-            page_token="abc", first_page_response=None  # not cached
+            page_token="abc",
+            first_page_response=None,  # not cached
         )
         result = iterator._should_use_bqstorage(
             bqstorage_client=None, create_bqstorage_client=True
@@ -2882,7 +2879,8 @@ def test__should_use_bqstorage_returns_false_if_page_token_set(self):
 
     def test__should_use_bqstorage_returns_false_if_max_results_set(self):
         iterator = self._make_one(
-            max_results=10, first_page_response=None  # not cached
+            max_results=10,
+            first_page_response=None,  # not cached
         )
         result = iterator._should_use_bqstorage(
             bqstorage_client=None, create_bqstorage_client=True
@@ -5599,8 +5597,7 @@ def test_to_geodataframe_no_geog(self):
         with self.assertRaisesRegex(
             TypeError,
             re.escape(
-                "There must be at least one GEOGRAPHY column"
-                " to create a GeoDataFrame"
+                "There must be at least one GEOGRAPHY column to create a GeoDataFrame"
             ),
         ):
             row_iterator.to_geodataframe(create_bqstorage_client=False)