Add multi-type support to bloom filter bindings

- Add efficient overloads for different Python data types:
  * uint64_t for non-negative integers
  * int64_t for negative/positive integers
  * double for floats
  * std::string for strings
  * bytes objects for binary data
- Use proper static_cast syntax for nanobind compatibility
- Add comprehensive unit test for all supported data types
- Remove memoryview support (not available in nanobind)
- All 16 bloom filter tests pass

Author: c-dickens

src/bloom_filter_wrapper.cpp

@@ -34,12 +34,57 @@ void bind_bloom_filter(nb::module_ &m, const char* name) {
   nb::class_<bloom_filter_type>(m, name)
     .def("is_empty", &bloom_filter_type::is_empty,
          "Returns True if the filter has seen no items, otherwise False")
+    
+    // Update methods - efficient overloads for Python types
+    // Non-negative integers (uint64_t)
+    .def("update", static_cast<void (bloom_filter_type::*)(uint64_t)>(&bloom_filter_type::update), 
+         nb::arg("item"),
+         "Updates the filter with a non-negative integer")
+    // Negative/positive integers (int64_t)
+    .def("update", static_cast<void (bloom_filter_type::*)(int64_t)>(&bloom_filter_type::update), 
+         nb::arg("item"),
+         "Updates the filter with a negative/positive integer")
+    // Float (double)
+    .def("update", static_cast<void (bloom_filter_type::*)(double)>(&bloom_filter_type::update), 
+         nb::arg("item"),
+         "Updates the filter with a float")
+    // String (std::string)
     .def("update", static_cast<void (bloom_filter_type::*)(const std::string&)>(&bloom_filter_type::update), 
          nb::arg("item"),
-         "Updates the filter with the given string")
+         "Updates the filter with a string")
+    // Bytes object
+    .def("update",
+         [](bloom_filter_type& self, nb::bytes b) {
+           self.update(b.c_str(), b.size());
+         },
+         nb::arg("item"),
+         "Updates the filter with a bytes object")
+    
+    // Query methods - efficient overloads for Python types
+    // Non-negative integers (uint64_t)
+    .def("query", static_cast<bool (bloom_filter_type::*)(uint64_t) const>(&bloom_filter_type::query), 
+         nb::arg("item"),
+         "Queries the filter for a non-negative integer")
+    // Negative/positive integers (int64_t)
+    .def("query", static_cast<bool (bloom_filter_type::*)(int64_t) const>(&bloom_filter_type::query), 
+         nb::arg("item"),
+         "Queries the filter for a negative/positive integer")
+    // Float (double)
+    .def("query", static_cast<bool (bloom_filter_type::*)(double) const>(&bloom_filter_type::query), 
+         nb::arg("item"),
+         "Queries the filter for a float")
+    // String (std::string)
     .def("query", static_cast<bool (bloom_filter_type::*)(const std::string&) const>(&bloom_filter_type::query), 
          nb::arg("item"),
-         "Queries the filter for the given string")
+         "Queries the filter for a string")
+    // Bytes object
+    .def("query",
+         [](const bloom_filter_type& self, nb::bytes b) -> bool {
+           return self.query(b.c_str(), b.size());
+         },
+         nb::arg("item"),
+         "Queries the filter for a bytes object")
+    
     .def("reset", &bloom_filter_type::reset,
          "Resets the Bloom filter to its original empty state")
     .def("get_serialized_size_bytes", 

tests/bloom_filter_test.py

@@ -84,6 +84,29 @@ def test_basic_operations(self):
         for i in range(num_items):
             self.assertTrue(new_bf.query(str(i)))
 
+    def test_update_types(self):
+        """Test update and query with different data types."""
+        bf = bloom_filter.create_by_accuracy(1000, 0.01)
+
+        # Test integers (positive and negative)
+        for v in [0, 1, 2**40, -1, -2**40]:
+            bf.update(v)
+            self.assertTrue(bf.query(v))
+
+        # Test floats
+        for v in [0.5, -3.25]:
+            bf.update(v)
+            self.assertTrue(bf.query(v))
+
+        # Test strings
+        bf.update("hello")
+        self.assertTrue(bf.query("hello"))
+
+        # Test bytes
+        b = b"abc\x00def"
+        bf.update(b)
+        self.assertTrue(bf.query(b))
+
     def test_reset_method(self):
         """Test the reset method functionality."""
         bf = bloom_filter.create_by_accuracy(1000, 0.01)