removes determine all and module reload tests

Author: chalmerlowe

db_dtypes/__init__.py

@@ -337,22 +337,6 @@ def __sub__(self, other):
         return super().__sub__(other)
 
 
-def _determine_all(json_array_type, json_dtype_type):
-    """Determines the list for __all__ based on JSON type availability."""
-    base_all = [
-        "__version__",
-        "DateArray",
-        "DateDtype",
-        "TimeArray",
-        "TimeDtype",
-    ]
-    # Check if both JSON types are available (truthy)
-    if json_array_type and json_dtype_type:
-        return base_all + ["JSONDtype", "JSONArray", "JSONArrowType"]
-    else:
-        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()
@@ -370,4 +354,13 @@ def _check_python_version():
 
 _check_python_version()
 
-__all__ = _determine_all(JSONArray, JSONDtype)
+__all__ = [
+    "__version__",
+    "DateArray",
+    "DateDtype",
+    "TimeArray",
+    "TimeDtype",
+    "JSONDtype",
+    "JSONArray",
+    "JSONArrowType",
+]

db_dtypes/json.py

@@ -277,10 +277,5 @@ def to_pandas_dtype(self):
 
 
 # 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
+# another Python process.
+pa.register_extension_type(JSONArrowType())

tests/unit/test__init__.py

@@ -83,62 +83,3 @@ def test_check_python_version_does_not_warn_on_supported(mock_version_tuple):
 
         # Assert that warnings.warn was NOT called
         mock_warn_call.assert_not_called()
-
-
-def test_determine_all_includes_json_when_available():
-    """
-    Test that _determine_all includes JSON types when both are truthy.
-    """
-
-    from db_dtypes import _determine_all
-
-    # Simulate available types (can be any truthy object)
-    mock_json_array = object()
-    mock_json_dtype = object()
-
-    result = _determine_all(mock_json_array, mock_json_dtype)
-
-    expected_all = [
-        "__version__",
-        "DateArray",
-        "DateDtype",
-        "TimeArray",
-        "TimeDtype",
-        "JSONDtype",
-        "JSONArray",
-        "JSONArrowType",
-    ]
-    assert set(result) == set(expected_all)
-    assert "JSONDtype" in result
-    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
-    ],
-)
-def test_determine_all_excludes_json_when_unavailable(mock_array, mock_dtype):
-    """
-    Test that _determine_all excludes JSON types if either is falsy.
-    """
-
-    from db_dtypes import _determine_all
-
-    result = _determine_all(mock_array, mock_dtype)
-
-    expected_all = [
-        "__version__",
-        "DateArray",
-        "DateDtype",
-        "TimeArray",
-        "TimeDtype",
-    ]
-    assert set(result) == set(expected_all)
-    assert "JSONDtype" not in result
-    assert "JSONArray" not in result
-    assert "JSONArrowType" not in result

tests/unit/test_json.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import json
-import sys
 
 import numpy as np
 import pandas as pd
@@ -227,76 +226,3 @@ def test_json_arrow_record_batch():
         == '{"null_field":null,"order":{"address":{"city":"Anytown","street":"123 Main St"},"items":["book","pen","computer"],"total":15}}'
     )
     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)
-
-    # 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())
-
-    except pa.ArrowKeyError:
-        pass  # Already registered is the state we want before the test runs
-
-    # Remove the module from sys.modules so importlib.reload which will happen
-    # after the yield statement will re-execute it
-    if json_module_name in sys.modules:  # pragma: NO COVER
-        del sys.modules[json_module_name]
-
-    yield  # Run the test that uses this fixture
-
-    # 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
-    elif json_module_name in sys.modules:  # pragma: NO COVER
-        # If the test re-imported it but it wasn't there originally, remove it
-        del sys.modules[json_module_name]
-
-    # Note: PyArrow doesn't have a public API to unregister types easily,
-    # thus we are using the testing pattern of module isolation/reloading.
-
-
-# Test specifically for the fixture's pre-yield removal logic
-def test_fixture_removes_module_if_present(cleanup_json_module_for_reload):
-    """
-    Tests that the cleanup_json_module_for_reload fixture removes
-    db_dtypes.json from sys.modules before yielding to the test.
-    This specifically targets the 'if json_module_name in sys.modules:' block.
-    """
-    # This test runs *after* the fixture's `yield`.
-    # The fixture should have removed the module if it was present.
-
-    json_module_name = "db_dtypes.json"
-
-    assert (
-        json_module_name not in sys.modules
-    ), f"The fixture cleanup_json_module_for_reload should have removed {json_module_name}"
-
-
-def test_json_arrow_type_reregistration_is_handled(cleanup_json_module_for_reload):
-    """
-    Verify that attempting to re-register JSONArrowType via module reload
-    is caught by the except block and does not raise an error.
-    """
-
-    # 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  # noqa: F401
-
-    assert True, "Module re-import completed without error, except block likely worked."