Fix P1 bug: Validate index when erasing last element

PROBLEM:
When tree has single element, erase() bypassed index validation and
silently deleted the element regardless of which index was requested.
Example: tree with index 5, calling erase(999) would succeed and
delete index 5 without error.

ROOT CAUSE:
The workaround for C++ library bug ("#roots is not 1") immediately
recreated an empty tree without validating that the requested index
actually existed in the tree.

FIX:
Call underlying _tree.erase(idx) first to validate the index:
- If "Given index is not found" -> re-raise (invalid index)
- If "#roots is not 1" -> recreate empty tree (valid index, library bug)
- Otherwise -> re-raise (other error)

TESTS ADDED:
- test_erase_non_existent_index: Now expects RuntimeError (was lenient)
- test_erase_non_existent_index_single_element: P1 bug regression test
- test_erase_valid_index_single_element: Verify valid erase still works

Result: 950 tests passed (6 new tests added)

Author: claude

src/python_prtree/__init__.py

@@ -58,9 +58,24 @@ def erase(self, idx):
 
         # Handle erasing the last element (library limitation workaround)
         if self.n == 1:
-            # Recreate an empty tree (workaround for C++ limitation)
-            self._tree = self.Klass()
-            return
+            # Call underlying erase to validate index, then handle the library bug
+            try:
+                self._tree.erase(idx)
+                # If we get here, erase succeeded (shouldn't happen with n==1)
+                return
+            except RuntimeError as e:
+                error_msg = str(e)
+                if "Given index is not found" in error_msg:
+                    # Index doesn't exist - re-raise the error
+                    raise
+                elif "#roots is not 1" in error_msg:
+                    # This is the library bug we're working around
+                    # Index was valid, so recreate empty tree
+                    self._tree = self.Klass()
+                    return
+                else:
+                    # Some other RuntimeError - re-raise it
+                    raise
 
         self._tree.erase(idx)
 

tests/unit/test_erase.py

@@ -56,7 +56,7 @@ def test_erase_from_empty_tree(self, PRTree, dim):
 
     @pytest.mark.parametrize("PRTree, dim", [(PRTree2D, 2), (PRTree3D, 3), (PRTree4D, 4)])
     def test_erase_non_existent_index(self, PRTree, dim):
-        """存在しないインデックスの削除の動作確認."""
+        """存在しないインデックスの削除がエラーになることを確認."""
         idx = np.array([1, 2])
         boxes = np.zeros((2, 2 * dim))
         for i in range(2):
@@ -66,15 +66,55 @@ def test_erase_non_existent_index(self, PRTree, dim):
 
         tree = PRTree(idx, boxes)
 
-        # Try to erase non-existent index
-        # Implementation may raise error or silently fail
-        try:
+        # Try to erase non-existent index - should raise error
+        with pytest.raises(RuntimeError, match="Given index is not found"):
             tree.erase(999)
-            # If no error, size should remain same
-            assert tree.size() == 2
-        except (ValueError, RuntimeError, KeyError):
-            # Error is also acceptable
-            pass
+
+        # Tree should be unchanged
+        assert tree.size() == 2
+
+    @pytest.mark.parametrize("PRTree, dim", [(PRTree2D, 2), (PRTree3D, 3), (PRTree4D, 4)])
+    def test_erase_non_existent_index_single_element(self, PRTree, dim):
+        """単一要素のツリーで存在しないインデックスの削除がエラーになることを確認 (P1 validation bug)."""
+        idx = np.array([5])
+        boxes = np.zeros((1, 2 * dim))
+        for d in range(dim):
+            boxes[0, d] = 0.0
+            boxes[0, d + dim] = 1.0
+
+        tree = PRTree(idx, boxes)
+        assert tree.size() == 1
+
+        # Try to erase non-existent index 999 - should raise error
+        # This is the P1 bug: previously silently deleted the real element
+        with pytest.raises(RuntimeError, match="Given index is not found"):
+            tree.erase(999)
+
+        # Tree should still contain the element
+        assert tree.size() == 1
+
+        # Verify the correct element is still there
+        query_box = boxes[0]
+        result = tree.query(query_box)
+        assert 5 in result
+
+    @pytest.mark.parametrize("PRTree, dim", [(PRTree2D, 2), (PRTree3D, 3), (PRTree4D, 4)])
+    def test_erase_valid_index_single_element(self, PRTree, dim):
+        """単一要素のツリーで有効なインデックスの削除が機能することを確認."""
+        idx = np.array([5])
+        boxes = np.zeros((1, 2 * dim))
+        for d in range(dim):
+            boxes[0, d] = 0.0
+            boxes[0, d + dim] = 1.0
+
+        tree = PRTree(idx, boxes)
+        assert tree.size() == 1
+
+        # Erase the valid index 5 - should succeed
+        tree.erase(5)
+
+        # Tree should now be empty
+        assert tree.size() == 0
 
 
 class TestConsistencyErase: