Define SortedDictKeys.__contains__ (#157)

Reduce fuzz test iterations to speed up GitHub Actions workflows. No difference in coverage observed.

Author: tfpf

pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pysorteddict"
-version = "0.7.2"
+version = "0.7.3"
 authors = [
     {name = "Vishal Pankaj Chandratreya"},
 ]

src/pysorteddict/sorted_dict_keys_type.cc

@@ -8,3 +8,8 @@ PyObject* SortedDictKeysIterType::next(void)
 {
     return Py_XNewRef(this->SortedDictViewIterType::next().first);  // 🆕
 }
+
+int SortedDictKeysType::contains(PyObject* key)
+{
+    return this->sd->contains(key);
+}

src/pysorteddict/sorted_dict_keys_type.hh

@@ -13,6 +13,7 @@ struct SortedDictKeysIterType : public SortedDictViewIterType
 
 struct SortedDictKeysType : public SortedDictViewType
 {
+    int contains(PyObject*);
 };
 
 #endif

src/pysorteddict/sorted_dict_module.cc

@@ -63,14 +63,24 @@ static PyObject* sorted_dict_keys_type_repr(PyObject* self)
 /**
  * Obtain the number of keys.
  */
-Py_ssize_t sorted_dict_keys_type_len(PyObject* self)
+static Py_ssize_t sorted_dict_keys_type_len(PyObject* self)
 {
     SortedDictKeysType* sdk = reinterpret_cast<SortedDictKeysType*>(self);
     return sdk->len();
 }
 
+/**
+ * Check whether a key is present.
+ */
+static int sorted_dict_keys_type_contains(PyObject* self, PyObject* key)
+{
+    SortedDictKeysType* sdk = reinterpret_cast<SortedDictKeysType*>(self);
+    return sdk->contains(key);
+}
+
 static PySequenceMethods sorted_dict_keys_type_sequence = {
     .sq_length = sorted_dict_keys_type_len,
+    .sq_contains = sorted_dict_keys_type_contains,
 };
 
 /**

tests/test_fuzz.py

@@ -54,7 +54,7 @@ def test_fuzz(self, key_type: type):
             "__len__", "__lt__", "__ne__", "__reduce__", "__reduce_ex__", "__repr__", "__setattr__", "__sizeof__",
             "__str__", "__subclasshook__", "__weakref__", "items", "key_type", "values",
         ))  # fmt: skip
-        for attr in self._rg.choices([*attrs], k=50_000):
+        for attr in self._rg.choices([*attrs], k=10_000):
             getattr(self, f"_test_{attr}")()
 
             with pytest.raises(TypeError, match="^unhashable type: 'pysorteddict.SortedDict'$"):
@@ -71,26 +71,27 @@ def test_fuzz(self, key_type: type):
             assert self.sorted_dict.values() == [*sorted_normal_dict.values()]
 
     def _test___contains__(self):
-        for key_type in all_types:
-            key = self._gen(key_type)
-            if self.is_sorted_dict_new:
-                with pytest.raises(RuntimeError, match="^key type not set: insert at least one item first$"):
-                    key in self.sorted_dict  # noqa: B015
-                continue
-            if key_type is not self.key_type:
-                with pytest.raises(
-                    TypeError,
-                    match=re.escape(f"got key {key!r} of type {key_type!r}, want key of type {self.key_type!r}"),
-                ):
-                    key in self.sorted_dict  # noqa: B015
-                continue
-            if (key_type is float or key_type is decimal.Decimal) and math.isnan(key):
-                with pytest.raises(ValueError, match=re.escape(f"got bad key {key!r} of type {key_type!r}")):
-                    key in self.sorted_dict  # noqa: B015
-                continue
-            if self.normal_dict:
-                assert self._rg.choice([*self.normal_dict]) in self.sorted_dict
-            assert (key in self.sorted_dict) == (key in self.normal_dict)
+        for sorted_dict_or_sorted_dict_keys in (self.sorted_dict, self.sorted_dict_keys):
+            for key_type in all_types:
+                key = self._gen(key_type)
+                if self.is_sorted_dict_new:
+                    with pytest.raises(RuntimeError, match="^key type not set: insert at least one item first$"):
+                        key in sorted_dict_or_sorted_dict_keys  # noqa: B015
+                    continue
+                if key_type is not self.key_type:
+                    with pytest.raises(
+                        TypeError,
+                        match=re.escape(f"got key {key!r} of type {key_type!r}, want key of type {self.key_type!r}"),
+                    ):
+                        key in sorted_dict_or_sorted_dict_keys  # noqa: B015
+                    continue
+                if (key_type is float or key_type is decimal.Decimal) and math.isnan(key):
+                    with pytest.raises(ValueError, match=re.escape(f"got bad key {key!r} of type {key_type!r}")):
+                        key in sorted_dict_or_sorted_dict_keys  # noqa: B015
+                    continue
+                if self.normal_dict:
+                    assert self._rg.choice([*self.normal_dict]) in sorted_dict_or_sorted_dict_keys
+                assert (key in sorted_dict_or_sorted_dict_keys) == (key in self.normal_dict)
 
     def _test___delattr__(self):
         with pytest.raises(AttributeError):