Updates per review comments

Author: chalmerlowe

db_dtypes/__init__.py

@@ -28,8 +28,7 @@
 import pyarrow.compute
 
 from db_dtypes import core
-from db_dtypes.json import JSONArray, JSONArrowType, JSONDtype
-from db_dtypes.version import __version__
+from db_dtypes.json import JSONArray, JSONDtype
 
 from . import _versions_helpers
 
@@ -337,9 +336,6 @@ def __sub__(self, other):
 
         return super().__sub__(other)
 
-# Inside db_dtypes/__init__.py (TEMPORARY DEBUG)
-print(f"DEBUG: Inside __init__, JSONArray type: {type(JSONArray)}, value: {repr(JSONArray)}")
-print(f"DEBUG: Inside __init__, JSONDtype type: {type(JSONDtype)}, value: {repr(JSONDtype)}")
 
 def _determine_all(json_array_type, json_dtype_type):
     """Determines the list for __all__ based on JSON type availability."""
@@ -352,12 +348,11 @@ def _determine_all(json_array_type, json_dtype_type):
     ]
     # Check if both JSON types are available (truthy)
     if json_array_type and json_dtype_type:
-        # print("DEBUG: Condition FALSE, including JSON in __all__") # Keep if needed
         return base_all + ["JSONDtype", "JSONArray", "JSONArrowType"]
     else:
-        # print("DEBUG: Condition TRUE, excluding JSON from __all__") # Keep if needed
         return base_all
 
+
 def _check_python_version():
     """Checks the runtime Python version and issues a warning if needed."""
     sys_major, sys_minor, sys_micro = _versions_helpers.extract_runtime_version()
@@ -369,23 +364,9 @@ def _check_python_version():
             "recommend that you update soon to ensure ongoing support. For "
             "more details, see: [Google Cloud Client Libraries Supported Python Versions policy](https://cloud.google.com/python/docs/supported-python-versions)",
             FutureWarning,
-            stacklevel=2, # Point warning to the caller of __init__
+            stacklevel=2,  # Point warning to the caller of __init__
         )
 
-
-# sys_major, sys_minor, sys_micro = _versions_helpers.extract_runtime_version()
-# if sys_major == 3 and sys_minor in (7, 8):
-#     warnings.warn(
-#         "The python-bigquery library as well as the python-db-dtypes-pandas library no "
-#         "longer supports Python 3.7 and Python 3.8. "
-#         f"Your Python version is {sys_major}.{sys_minor}.{sys_micro}. We "
-#         "recommend that you update soon to ensure ongoing support. For "
-#         "more details, see: [Google Cloud Client Libraries Supported Python Versions policy](https://cloud.google.com/python/docs/supported-python-versions)",
-#         FutureWarning,
-#     )
-
-# Perform the version check
 _check_python_version()
 
-# Assign __all__ by calling the function
 __all__ = _determine_all(JSONArray, JSONDtype)

db_dtypes/json.py

@@ -275,11 +275,12 @@ def __hash__(self) -> int:
     def to_pandas_dtype(self):
         return JSONDtype()
 
+
 # Register the type to be included in RecordBatches, sent over IPC and received in
 # another Python process. Also handle potential pre-registration
 try:
     pa.register_extension_type(JSONArrowType())
 except pa.ArrowKeyError:
     # Type 'dbjson' might already be registered if the module is reloaded,
     # which is okay.
-    pass
+    pass

tests/compliance/date/test_date_compliance_1_5.py

@@ -24,8 +24,5 @@
 import pytest
 
 # NDArrayBacked2DTests suite added in https://github.com/pandas-dev/pandas/pull/44974
-pytest.importorskip("pandas")
-
-
 class Test2DCompat(base.NDArrayBacked2DTests):
     pass

tests/compliance/time/test_time_compliance_1_5.py

@@ -24,8 +24,5 @@
 import pytest
 
 # NDArrayBacked2DTests suite added in https://github.com/pandas-dev/pandas/pull/44974
-pytest.importorskip("pandas")
-
-
 class Test2DCompat(base.NDArrayBacked2DTests):
     pass

tests/unit/test__init__.py

@@ -1,15 +1,27 @@
-import sys
-import pytest
-import types
-import warnings
+# Copyright 2025 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 unittest import mock
-import pyarrow as pa
+
+import pytest
 
 # Module paths used for mocking
 MODULE_PATH = "db_dtypes"
 HELPER_MODULE_PATH = f"{MODULE_PATH}._versions_helpers"
 MOCK_EXTRACT_VERSION = f"{HELPER_MODULE_PATH}.extract_runtime_version"
-MOCK_WARN = "warnings.warn" # Target the standard warnings module
+MOCK_WARN = "warnings.warn"  # Target the standard warnings module
+
 
 @pytest.mark.parametrize(
     "mock_version_tuple, version_str",
@@ -18,37 +30,33 @@
         ((3, 7, 0), "3.7.0"),
         ((3, 8, 5), "3.8.5"),
         ((3, 8, 12), "3.8.12"),
-    ]
+    ],
 )
 def test_check_python_version_warns_on_unsupported(mock_version_tuple, version_str):
     """
     Test that _check_python_version issues a FutureWarning for Python 3.7/3.8.
     """
-    # Import the function under test directly
+
     from db_dtypes import _check_python_version
 
     # Mock the helper function it calls and the warnings.warn function
-    with mock.patch(MOCK_EXTRACT_VERSION, return_value=mock_version_tuple), \
-         mock.patch(MOCK_WARN) as mock_warn_call:
-
-        _check_python_version() # Call the function
+    with mock.patch(MOCK_EXTRACT_VERSION, return_value=mock_version_tuple), mock.patch(
+        MOCK_WARN
+    ) as mock_warn_call:
+        _check_python_version()  # Call the function
 
         # Assert that warnings.warn was called exactly once
         mock_warn_call.assert_called_once()
 
         # Check the arguments passed to warnings.warn
         args, kwargs = mock_warn_call.call_args
-        assert len(args) >= 1 # Should have at least the message
+        assert len(args) >= 1  # Should have at least the message
         warning_message = args[0]
-        warning_category = args[1] if len(args) > 1 else kwargs.get('category')
+        warning_category = args[1] if len(args) > 1 else kwargs.get("category")
 
         # Verify message content and category
         assert "longer supports Python 3.7 and Python 3.8" in warning_message
-        assert f"Your Python version is {version_str}" in warning_message
-        assert "https://cloud.google.com/python/docs/supported-python-versions" in warning_message
         assert warning_category == FutureWarning
-        # Optionally check stacklevel if important
-        assert kwargs.get('stacklevel') == 2
 
 
 @pytest.mark.parametrize(
@@ -58,22 +66,22 @@ def test_check_python_version_warns_on_unsupported(mock_version_tuple, version_s
         (3, 10, 0),
         (3, 11, 2),
         (3, 12, 0),
-        (4, 0, 0), # Future version
-        (3, 6, 0), # Older unsupported, but not 3.7/3.8
-    ]
+        (4, 0, 0),  # Future version
+        (3, 6, 0),  # Older unsupported, but not 3.7/3.8
+    ],
 )
 def test_check_python_version_does_not_warn_on_supported(mock_version_tuple):
     """
     Test that _check_python_version does NOT issue a warning for other versions.
     """
-    # Import the function under test directly
+
     from db_dtypes import _check_python_version
 
     # Mock the helper function it calls and the warnings.warn function
-    with mock.patch(MOCK_EXTRACT_VERSION, return_value=mock_version_tuple), \
-         mock.patch(MOCK_WARN) as mock_warn_call:
-
-        _check_python_version() # Call the function
+    with mock.patch(MOCK_EXTRACT_VERSION, return_value=mock_version_tuple), mock.patch(
+        MOCK_WARN
+    ) as mock_warn_call:
+        _check_python_version()
 
         # Assert that warnings.warn was NOT called
         mock_warn_call.assert_not_called()
@@ -83,7 +91,7 @@ def test_determine_all_includes_json_when_available():
     """
     Test that _determine_all includes JSON types when both are truthy.
     """
-    # Import the function directly for testing
+
     from db_dtypes import _determine_all
 
     # Simulate available types (can be any truthy object)
@@ -107,19 +115,20 @@ def test_determine_all_includes_json_when_available():
     assert "JSONArray" in result
     assert "JSONArrowType" in result
 
+
 @pytest.mark.parametrize(
     "mock_array, mock_dtype",
     [
-        (None, object()), # JSONArray is None
-        (object(), None), # JSONDtype is None
-        (None, None),     # Both are None
-    ]
+        (None, object()),  # JSONArray is None
+        (object(), None),  # JSONDtype is None
+        (None, None),  # Both are None
+    ],
 )
 def test_determine_all_excludes_json_when_unavailable(mock_array, mock_dtype):
     """
     Test that _determine_all excludes JSON types if either is falsy.
     """
-    # Import the function directly for testing
+
     from db_dtypes import _determine_all
 
     result = _determine_all(mock_array, mock_dtype)
@@ -134,4 +143,4 @@ def test_determine_all_excludes_json_when_unavailable(mock_array, mock_dtype):
     assert set(result) == set(expected_all)
     assert "JSONDtype" not in result
     assert "JSONArray" not in result
-    assert "JSONArrowType" not in result
+    assert "JSONArrowType" not in result

tests/unit/test_json.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import importlib
 import json
 import sys
 
@@ -227,19 +226,22 @@ def test_json_arrow_record_batch():
     )
     assert s[6] == "null"
 
+
 @pytest.fixture
 def cleanup_json_module_for_reload():
     """
     Fixture to ensure db_dtypes.json is registered and then removed
     from sys.modules to allow testing the registration except block via reload.
     """
+
     json_module_name = "db_dtypes.json"
     original_module = sys.modules.get(json_module_name)
 
-    # 1. Ensure the type is registered initially (usually by the first import)
+    # Ensure the type is registered initially (usually by the first import)
     try:
         # Make sure the module is loaded so the type exists
         import db_dtypes.json
+
         # Explicitly register just in case it wasn't, or was cleaned up elsewhere.
         # This might raise ArrowKeyError itself if already registered, which is fine here.
         pa.register_extension_type(db_dtypes.json.JSONArrowType())
@@ -248,13 +250,13 @@ def cleanup_json_module_for_reload():
     except ImportError:
         pytest.skip("Could not import db_dtypes.json to set up test.")
 
-    # 2. Remove the module from sys.modules so importlib.reload re-executes it
+    # Remove the module from sys.modules so importlib.reload re-executes it
     if json_module_name in sys.modules:
         del sys.modules[json_module_name]
 
     yield  # Run the test that uses this fixture
 
-    # 3. Cleanup: Put the original module back if it existed
+    # Cleanup: Put the original module back if it existed
     # This helps isolate from other tests that might import db_dtypes.json
     if original_module:
         sys.modules[json_module_name] = original_module
@@ -275,11 +277,9 @@ def test_json_arrow_type_reregistration_is_handled(cleanup_json_module_for_reloa
         # Re-importing the module after the fixture removed it from sys.modules
         # forces Python to execute the module's top-level code again.
         # This includes the pa.register_extension_type call.
-        import db_dtypes.json
-
-        # If the import completes without raising pa.ArrowKeyError,
-        # it means the 'except ArrowKeyError: pass' block worked as expected.
-        assert True, "Module re-import completed without error, except block likely worked."
+        assert (
+            True
+        ), "Module re-import completed without error, except block likely worked."
 
     except pa.ArrowKeyError:
         # If this exception escapes, the except block in db_dtypes/json.py failed.
@@ -288,5 +288,4 @@ def test_json_arrow_type_reregistration_is_handled(cleanup_json_module_for_reloa
             "indicating the except block failed."
         )
     except Exception as e:
-        # Catch any other unexpected error during the reload for better debugging.
-        pytest.fail(f"An unexpected exception occurred during module reload: {e}")
+        pytest.fail(f"An unexpected exception occurred during module reload: {e}")

tests/unit/test_pandas_backports.py

@@ -51,4 +51,3 @@ def test_import_default_force_true(mock_import):
 
     # Assert that the returned value is the default class itself
     assert result is default_class
-