datasketches 0.3.1 → 0.3.2

data/vendor/datasketches-cpp/python/src/req_wrapper.cpp

@@ -17,199 +17,138 @@
  * under the License.
  */
 
+#include "py_object_lt.hpp"
+#include "py_object_ostream.hpp"
+#include "quantile_conditional.hpp"
 #include "req_sketch.hpp"
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/numpy.h>
-#include <sstream>
 #include <vector>
 #include <stdexcept>
 
 namespace py = pybind11;
 
-namespace datasketches {
-
-namespace python {
-
-template<typename T>
-req_sketch<T> req_sketch_deserialize(py::bytes sk_bytes) {
-  std::string sk_str = sk_bytes; // implicit cast  
-  return req_sketch<T>::deserialize(sk_str.c_str(), sk_str.length());
-}
-
-template<typename T>
-py::object req_sketch_serialize(const req_sketch<T>& sk) {
-  auto ser_result = sk.serialize();
-  return py::bytes((char*)ser_result.data(), ser_result.size());
-}
-
-// maybe possible to disambiguate the static vs method rank error calls, but
-// this is easier for now
-template<typename T>
-double req_sketch_generic_normalized_rank_error(uint16_t k, bool pmf) {
-  return req_sketch<T>::get_normalized_rank_error(k, pmf);
-}
-
-template<typename T>
-py::list req_sketch_get_quantiles(const req_sketch<T>& sk,
-                                  std::vector<double>& ranks,
-                                  bool inclusive) {
-  size_t n_quantiles = ranks.size();
-  auto result = sk.get_quantiles(ranks.data(), n_quantiles, inclusive);
-  // returning as std::vector<> would copy values to a list anyway
-  py::list list(n_quantiles);
-  for (size_t i = 0; i < n_quantiles; ++i) {
-      list[i] = result[i];
-  }
-  return list;
-}
-
-template<typename T>
-py::list req_sketch_get_pmf(const req_sketch<T>& sk,
-                            std::vector<T>& split_points,
-                            bool inclusive) {
-  size_t n_points = split_points.size();
-  auto result = sk.get_PMF(split_points.data(), n_points, inclusive);
-  py::list list(n_points + 1);
-  for (size_t i = 0; i <= n_points; ++i) {
-    list[i] = result[i];
-  }
-  return list;
-}
-
-template<typename T>
-py::list req_sketch_get_cdf(const req_sketch<T>& sk,
-                            std::vector<T>& split_points,
-                            bool inclusive) {
-  size_t n_points = split_points.size();
-  auto result = sk.get_CDF(split_points.data(), n_points, inclusive);
-  py::list list(n_points + 1);
-  for (size_t i = 0; i <= n_points; ++i) {
-    list[i] = result[i];
-  }
-  return list;
-}
-
-template<typename T>
-void req_sketch_update(req_sketch<T>& sk, py::array_t<T, py::array::c_style | py::array::forcecast> items) {
-  if (items.ndim() != 1) {
-    throw std::invalid_argument("input data must have only one dimension. Found: "
-          + std::to_string(items.ndim()));
-  }
-  
-  auto data = items.template unchecked<1>();
-  for (uint32_t i = 0; i < data.size(); ++i) {
-    sk.update(data(i));
-  }
-}
-
-}
-}
-
-namespace dspy = datasketches::python;
-
-template<typename T>
+template<typename T, typename C>
 void bind_req_sketch(py::module &m, const char* name) {
   using namespace datasketches;
 
-  py::class_<req_sketch<T>>(m, name)
+  auto req_class = py::class_<req_sketch<T, C>>(m, name)
     .def(py::init<uint16_t, bool>(), py::arg("k")=12, py::arg("is_hra")=true)
-    .def(py::init<const req_sketch<T>&>())
-    .def("update", (void (req_sketch<T>::*)(const T&)) &req_sketch<T>::update, py::arg("item"),
-         "Updates the sketch with the given value")
-    .def("update", &dspy::req_sketch_update<T>, py::arg("array"),
-         "Updates the sketch with the values in the given array")
-    .def("merge", (void (req_sketch<T>::*)(const req_sketch<T>&)) &req_sketch<T>::merge, py::arg("sketch"),
-         "Merges the provided sketch into the this one")
-    .def("__str__", &req_sketch<T>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
-         "Produces a string summary of the sketch")
-    .def("to_string", &req_sketch<T>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
-         "Produces a string summary of the sketch")
-    .def("is_hra", &req_sketch<T>::is_HRA,
-         "Returns True if the sketch is in High Rank Accuracy mode, otherwise False")
-    .def("is_empty", &req_sketch<T>::is_empty,
-         "Returns True if the sketch is empty, otherwise False")
-    .def("get_k", &req_sketch<T>::get_k,
-         "Returns the configured parameter k")
-    .def("get_n", &req_sketch<T>::get_n,
-         "Returns the length of the input stream")
-    .def("get_num_retained", &req_sketch<T>::get_num_retained,
-         "Returns the number of retained items (samples) in the sketch")
-    .def("is_estimation_mode", &req_sketch<T>::is_estimation_mode,
-         "Returns True if the sketch is in estimation mode, otherwise False")
-    .def("get_min_value", &req_sketch<T>::get_min_item,
-         "Returns the minimum value from the stream. If empty, req_floats_sketch returns nan; req_ints_sketch throws a RuntimeError")
-    .def("get_max_value", &req_sketch<T>::get_max_item,
-         "Returns the maximum value from the stream. If empty, req_floats_sketch returns nan; req_ints_sketch throws a RuntimeError")
-    .def("get_quantile", &req_sketch<T>::get_quantile, py::arg("rank"), py::arg("inclusive")=false,
-         "Returns an approximation to the data value "
-         "associated with the given normalized rank in a hypothetical sorted "
-         "version of the input stream so far.\n"
-         "For req_floats_sketch: if the sketch is empty this returns nan. "
-         "For req_ints_sketch: if the sketch is empty this throws a RuntimeError.")
-    .def("get_quantiles", &dspy::req_sketch_get_quantiles<T>, py::arg("ranks"), py::arg("inclusive")=false,
-         "This returns an array that could have been generated by using get_quantile() for each "
-         "normalized rank separately.\n"
-         "If the sketch is empty this returns an empty vector.\n"
-         "Deprecated. Will be removed in the next major version. Use get_quantile() instead.")
-    .def("get_rank", &req_sketch<T>::get_rank, py::arg("value"), py::arg("inclusive")=false,
-         "Returns an approximation to the normalized rank of the given value from 0 to 1, inclusive.\n"
-         "The resulting approximation has a probabilistic guarantee that can be obtained from the "
-         "get_normalized_rank_error(False) function.\n"
-         "With the parameter inclusive=true the weight of the given value is included into the rank."
-         "Otherwise the rank equals the sum of the weights of values less than the given value.\n"
-         "If the sketch is empty this returns nan.")
-    .def("get_pmf", &dspy::req_sketch_get_pmf<T>, py::arg("split_points"), py::arg("inclusive")=false,
-         "Returns an approximation to the Probability Mass Function (PMF) of the input stream "
-         "given a set of split points (values).\n"
-         "The resulting approximations have a probabilistic guarantee that can be obtained from the "
-         "get_normalized_rank_error(True) function.\n"
-         "If the sketch is empty this returns an empty vector.\n"
-         "split_points is an array of m unique, monotonically increasing float values "
-         "that divide the real number line into m+1 consecutive disjoint intervals.\n"
-         "If the parameter inclusive=false, the definition of an 'interval' is inclusive of the left split point (or minimum value) and "
-         "exclusive of the right split point, with the exception that the last interval will include "
-         "the maximum value.\n"
-         "If the parameter inclusive=true, the definition of an 'interval' is exclusive of the left split point (or minimum value) and "
-         "inclusive of the right split point.\n"
-         "It is not necessary to include either the min or max values in these split points.")
-    .def("get_cdf", &dspy::req_sketch_get_cdf<T>, py::arg("split_points"), py::arg("inclusive")=false,
-         "Returns an approximation to the Cumulative Distribution Function (CDF), which is the "
-         "cumulative analog of the PMF, of the input stream given a set of split points (values).\n"
-         "The resulting approximations have a probabilistic guarantee that can be obtained from the "
-         "get_normalized_rank_error(True) function.\n"
-         "If the sketch is empty this returns an empty vector.\n"
-         "split_points is an array of m unique, monotonically increasing float values "
-         "that divide the real number line into m+1 consecutive disjoint intervals.\n"
-         "If the parameter inclusive=false, the definition of an 'interval' is inclusive of the left split point (or minimum value) and "
-         "exclusive of the right split point, with the exception that the last interval will include "
-         "the maximum value.\n"
-         "If the parameter inclusive=true, the definition of an 'interval' is exclusive of the left split point (or minimum value) and "
-         "inclusive of the right split point.\n"
-         "It is not necessary to include either the min or max values in these split points.")
-    .def("get_rank_lower_bound", &req_sketch<T>::get_rank_lower_bound, py::arg("rank"), py::arg("num_std_dev"),
-         "Returns an approximate lower bound on the given normalized rank.\n"
-         "Normalized rank must be a value between 0.0 and 1.0 (inclusive); "
-         "the number of standard deviations must be 1, 2, or 3.")
-    .def("get_rank_upper_bound", &req_sketch<T>::get_rank_upper_bound, py::arg("rank"), py::arg("num_std_dev"),
-         "Returns an approximate upper bound on the given normalized rank.\n"
-         "Normalized rank must be a value between 0.0 and 1.0 (inclusive); "
-         "the number of standard deviations must be 1, 2, or 3.")
-    .def_static("get_RSE", &req_sketch<T>::get_RSE,
-         py::arg("k"), py::arg("rank"), py::arg("is_hra"), py::arg("n"),
-         "Returns an a priori estimate of relative standard error (RSE, expressed as a number in [0,1]). "
-         "Derived from Lemma 12 in http://arxiv.org/abs/2004.01668v2, but the constant factors have been "
-         "modified based on empirical measurements, for a given value of parameter k.\n"
-         "Normalized rank must be a value between 0.0 and 1.0 (inclusive). If is_hra is True, uses high "
-         "rank accuracy mode, else low rank accuracy. N is an estimate of the total number of points "
-         "provided to the sketch.")
-    .def("serialize", &dspy::req_sketch_serialize<T>, "Serializes the sketch into a bytes object")
-    .def_static("deserialize", &dspy::req_sketch_deserialize<T>, "Deserializes the sketch from a bytes object")
-    ;
+    .def(py::init<const req_sketch<T, C>&>())
+    .def("update", (void (req_sketch<T, C>::*)(const T&)) &req_sketch<T, C>::update, py::arg("item"),
+        "Updates the sketch with the given value")
+    .def("merge", (void (req_sketch<T, C>::*)(const req_sketch<T, C>&)) &req_sketch<T, C>::merge, py::arg("sketch"),
+        "Merges the provided sketch into this one")
+    .def("__str__", &req_sketch<T, C>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
+        "Produces a string summary of the sketch")
+    .def("to_string", &req_sketch<T, C>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
+        "Produces a string summary of the sketch")
+    .def("is_hra", &req_sketch<T, C>::is_HRA,
+        "Returns True if the sketch is in High Rank Accuracy mode, otherwise False")
+    .def("is_empty", &req_sketch<T, C>::is_empty,
+        "Returns True if the sketch is empty, otherwise False")
+    .def("get_k", &req_sketch<T, C>::get_k,
+        "Returns the configured parameter k")
+    .def("get_n", &req_sketch<T, C>::get_n,
+        "Returns the length of the input stream")
+    .def("get_num_retained", &req_sketch<T, C>::get_num_retained,
+        "Returns the number of retained items (samples) in the sketch")
+    .def("is_estimation_mode", &req_sketch<T, C>::is_estimation_mode,
+        "Returns True if the sketch is in estimation mode, otherwise False")
+    .def("get_min_value", &req_sketch<T, C>::get_min_item,
+        "Returns the minimum value from the stream. If empty, req_floats_sketch returns nan; req_ints_sketch throws a RuntimeError")
+    .def("get_max_value", &req_sketch<T, C>::get_max_item,
+        "Returns the maximum value from the stream. If empty, req_floats_sketch returns nan; req_ints_sketch throws a RuntimeError")
+    .def("get_quantile", &req_sketch<T, C>::get_quantile, py::arg("rank"), py::arg("inclusive")=false,
+        "Returns an approximation to the data value "
+        "associated with the given normalized rank in a hypothetical sorted "
+        "version of the input stream so far.\n"
+        "For req_floats_sketch: if the sketch is empty this returns nan. "
+        "For req_ints_sketch: if the sketch is empty this throws a RuntimeError.")
+    .def(
+        "get_quantiles",
+        [](const req_sketch<T, C>& sk, const std::vector<double>& ranks, bool inclusive) {
+          return sk.get_quantiles(ranks.data(), ranks.size(), inclusive);
+        },
+        py::arg("ranks"), py::arg("inclusive")=false,
+        "This returns an array that could have been generated by using get_quantile() for each "
+        "normalized rank separately.\n"
+        "If the sketch is empty this returns an empty vector.\n"
+        "Deprecated. Will be removed in the next major version. Use get_quantile() instead."
+    )
+    .def("get_rank", &req_sketch<T, C>::get_rank, py::arg("value"), py::arg("inclusive")=false,
+        "Returns an approximation to the normalized rank of the given value from 0 to 1, inclusive.\n"
+        "The resulting approximation has a probabilistic guarantee that can be obtained from the "
+        "get_normalized_rank_error(False) function.\n"
+        "With the parameter inclusive=true the weight of the given value is included into the rank."
+        "Otherwise the rank equals the sum of the weights of values less than the given value.\n"
+        "If the sketch is empty this returns nan.")
+    .def(
+        "get_pmf",
+        [](const req_sketch<T, C>& sk, const std::vector<T>& split_points, bool inclusive) {
+          return sk.get_PMF(split_points.data(), split_points.size(), inclusive);
+        },
+        py::arg("split_points"), py::arg("inclusive")=false,
+        "Returns an approximation to the Probability Mass Function (PMF) of the input stream "
+        "given a set of split points (values).\n"
+        "The resulting approximations have a probabilistic guarantee that can be obtained from the "
+        "get_normalized_rank_error(True) function.\n"
+        "If the sketch is empty this returns an empty vector.\n"
+        "split_points is an array of m unique, monotonically increasing float values "
+        "that divide the real number line into m+1 consecutive disjoint intervals.\n"
+        "If the parameter inclusive=false, the definition of an 'interval' is inclusive of the left split point (or minimum value) and "
+        "exclusive of the right split point, with the exception that the last interval will include "
+        "the maximum value.\n"
+        "If the parameter inclusive=true, the definition of an 'interval' is exclusive of the left split point (or minimum value) and "
+        "inclusive of the right split point.\n"
+        "It is not necessary to include either the min or max values in these split points."
+    )
+    .def(
+        "get_cdf",
+        [](const req_sketch<T, C>& sk, const std::vector<T>& split_points, bool inclusive) {
+          return sk.get_CDF(split_points.data(), split_points.size(), inclusive);
+        },
+        py::arg("split_points"), py::arg("inclusive")=false,
+        "Returns an approximation to the Cumulative Distribution Function (CDF), which is the "
+        "cumulative analog of the PMF, of the input stream given a set of split points (values).\n"
+        "The resulting approximations have a probabilistic guarantee that can be obtained from the "
+        "get_normalized_rank_error(True) function.\n"
+        "If the sketch is empty this returns an empty vector.\n"
+        "split_points is an array of m unique, monotonically increasing float values "
+        "that divide the real number line into m+1 consecutive disjoint intervals.\n"
+        "If the parameter inclusive=false, the definition of an 'interval' is inclusive of the left split point (or minimum value) and "
+        "exclusive of the right split point, with the exception that the last interval will include "
+        "the maximum value.\n"
+        "If the parameter inclusive=true, the definition of an 'interval' is exclusive of the left split point (or minimum value) and "
+        "inclusive of the right split point.\n"
+        "It is not necessary to include either the min or max values in these split points."
+    )
+    .def("get_rank_lower_bound", &req_sketch<T, C>::get_rank_lower_bound, py::arg("rank"), py::arg("num_std_dev"),
+        "Returns an approximate lower bound on the given normalized rank.\n"
+        "Normalized rank must be a value between 0.0 and 1.0 (inclusive); "
+        "the number of standard deviations must be 1, 2, or 3.")
+    .def("get_rank_upper_bound", &req_sketch<T, C>::get_rank_upper_bound, py::arg("rank"), py::arg("num_std_dev"),
+        "Returns an approximate upper bound on the given normalized rank.\n"
+        "Normalized rank must be a value between 0.0 and 1.0 (inclusive); "
+        "the number of standard deviations must be 1, 2, or 3.")
+    .def_static("get_RSE", &req_sketch<T, C>::get_RSE,
+        py::arg("k"), py::arg("rank"), py::arg("is_hra"), py::arg("n"),
+        "Returns an a priori estimate of relative standard error (RSE, expressed as a number in [0,1]). "
+        "Derived from Lemma 12 in http://arxiv.org/abs/2004.01668v2, but the constant factors have been "
+        "modified based on empirical measurements, for a given value of parameter k.\n"
+        "Normalized rank must be a value between 0.0 and 1.0 (inclusive). If is_hra is True, uses high "
+        "rank accuracy mode, else low rank accuracy. N is an estimate of the total number of points "
+        "provided to the sketch.")
+    .def("__iter__", [](const req_sketch<T, C>& s) { return py::make_iterator(s.begin(), s.end()); });
+
+    add_serialization<T>(req_class);
+    add_vector_update<T>(req_class);
 }
 
 void init_req(py::module &m) {
-  bind_req_sketch<int>(m, "req_ints_sketch");
-  bind_req_sketch<float>(m, "req_floats_sketch");
+  bind_req_sketch<int, std::less<int>>(m, "req_ints_sketch");
+  bind_req_sketch<float, std::less<float>>(m, "req_floats_sketch");
+  bind_req_sketch<py::object, py_object_lt>(m, "req_items_sketch");
 }

data/vendor/datasketches-cpp/python/src/theta_wrapper.cpp

@@ -17,7 +17,6 @@
  * under the License.
  */
 
-#include <sstream>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
@@ -28,51 +27,8 @@
 #include "theta_jaccard_similarity.hpp"
 #include "common_defs.hpp"
 
-
 namespace py = pybind11;
 
-namespace datasketches {
-namespace python {
-
-update_theta_sketch update_theta_sketch_factory(uint8_t lg_k, double p, uint64_t seed) {
-  update_theta_sketch::builder builder;
-  builder.set_lg_k(lg_k);
-  builder.set_p(p);
-  builder.set_seed(seed);
-  return builder.build();
-}
-
-theta_union theta_union_factory(uint8_t lg_k, double p, uint64_t seed) {
-  theta_union::builder builder;
-  builder.set_lg_k(lg_k);
-  builder.set_p(p);
-  builder.set_seed(seed);
-  return builder.build();
-}
-
-uint16_t theta_sketch_get_seed_hash(const theta_sketch& sk) {
-  return sk.get_seed_hash();
-}
-
-py::object compact_theta_sketch_serialize(const compact_theta_sketch& sk) {
-  auto serResult = sk.serialize();
-  return py::bytes((char*)serResult.data(), serResult.size());
-}
-
-compact_theta_sketch compact_theta_sketch_deserialize(py::bytes skBytes, uint64_t seed) {
-  std::string skStr = skBytes; // implicit cast  
-  return compact_theta_sketch::deserialize(skStr.c_str(), skStr.length(), seed);
-}
-
-py::list theta_jaccard_sim_computation(const theta_sketch& sketch_a, const theta_sketch& sketch_b, uint64_t seed) {
-  return py::cast(theta_jaccard_similarity::jaccard(sketch_a, sketch_b, seed));
-}
-
-}
-}
-
-namespace dspy = datasketches::python;
-
 void init_theta(py::module &m) {
   using namespace datasketches;
 
@@ -93,17 +49,24 @@ void init_theta(py::module &m) {
          "Returns True if sketch is in estimation mode, otherwise False")
     .def("get_theta", &theta_sketch::get_theta,
          "Returns theta (effective sampling rate) as a fraction from 0 to 1")
+    .def("get_theta64", &theta_sketch::get_theta64,
+         "Returns theta as 64-bit value")
     .def("get_num_retained", &theta_sketch::get_num_retained,
-         "Retunrs the number of items currently in the sketch")
-    .def("get_seed_hash", &dspy::theta_sketch_get_seed_hash,
+         "Returns the number of items currently in the sketch")
+    .def("get_seed_hash", &theta_sketch::get_seed_hash,
          "Returns a hash of the seed used in the sketch")
     .def("is_ordered", &theta_sketch::is_ordered,
          "Returns True if the sketch entries are sorted, otherwise False")
+    .def("__iter__", [](const theta_sketch& s) { return py::make_iterator(s.begin(), s.end()); })
   ;
 
   py::class_<update_theta_sketch, theta_sketch>(m, "update_theta_sketch")
-    .def(py::init(&dspy::update_theta_sketch_factory),
-         py::arg("lg_k")=theta_constants::DEFAULT_LG_K, py::arg("p")=1.0, py::arg("seed")=DEFAULT_SEED)
+    .def(
+        py::init([](uint8_t lg_k, double p, uint64_t seed) {
+          return update_theta_sketch::builder().set_lg_k(lg_k).set_p(p).set_seed(seed).build();
+        }),
+        py::arg("lg_k")=theta_constants::DEFAULT_LG_K, py::arg("p")=1.0, py::arg("seed")=DEFAULT_SEED
+    )
     .def(py::init<const update_theta_sketch&>())
     .def("update", (void (update_theta_sketch::*)(int64_t)) &update_theta_sketch::update, py::arg("datum"),
          "Updates the sketch with the given integral value")
@@ -118,16 +81,30 @@ void init_theta(py::module &m) {
   py::class_<compact_theta_sketch, theta_sketch>(m, "compact_theta_sketch")
     .def(py::init<const compact_theta_sketch&>())
     .def(py::init<const theta_sketch&, bool>())
-    .def("serialize", &dspy::compact_theta_sketch_serialize,
-        "Serializes the sketch into a bytes object")
-    .def_static("deserialize", &dspy::compact_theta_sketch_deserialize,
+    .def(
+        "serialize",
+        [](const compact_theta_sketch& sk) {
+          auto bytes = sk.serialize();
+          return py::bytes(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+        },
+        "Serializes the sketch into a bytes object"
+    )
+    .def_static(
+        "deserialize",
+        [](const std::string& bytes, uint64_t seed) {
+          return compact_theta_sketch::deserialize(bytes.data(), bytes.size(), seed);
+        },
         py::arg("bytes"), py::arg("seed")=DEFAULT_SEED,
-        "Reads a bytes object and returns the corresponding compact_theta_sketch")        
-  ;
+        "Reads a bytes object and returns the corresponding compact_theta_sketch"
+    );
 
   py::class_<theta_union>(m, "theta_union")
-    .def(py::init(&dspy::theta_union_factory),
-         py::arg("lg_k")=theta_constants::DEFAULT_LG_K, py::arg("p")=1.0, py::arg("seed")=DEFAULT_SEED)
+    .def(
+        py::init([](uint8_t lg_k, double p, uint64_t seed) {
+          return theta_union::builder().set_lg_k(lg_k).set_p(p).set_seed(seed).build();
+        }),
+        py::arg("lg_k")=theta_constants::DEFAULT_LG_K, py::arg("p")=1.0, py::arg("seed")=DEFAULT_SEED
+    )
     .def("update", &theta_union::update<const theta_sketch&>, py::arg("sketch"),
          "Updates the union with the given sketch")
     .def("get_result", &theta_union::get_result, py::arg("ordered")=true,
@@ -147,26 +124,43 @@ void init_theta(py::module &m) {
 
   py::class_<theta_a_not_b>(m, "theta_a_not_b")
     .def(py::init<uint64_t>(), py::arg("seed")=DEFAULT_SEED)
-    .def("compute", &theta_a_not_b::compute<const theta_sketch&, const theta_sketch&>, py::arg("a"), py::arg("b"), py::arg("ordered")=true,
-         "Returns a sketch with the reuslt of appying the A-not-B operation on the given inputs")
+    .def(
+        "compute",
+        &theta_a_not_b::compute<const theta_sketch&, const theta_sketch&>,
+        py::arg("a"), py::arg("b"), py::arg("ordered")=true,
+        "Returns a sketch with the result of applying the A-not-B operation on the given inputs"
+    )
   ;
   
   py::class_<theta_jaccard_similarity>(m, "theta_jaccard_similarity")
-     .def_static("jaccard", &dspy::theta_jaccard_sim_computation,
-                 py::arg("sketch_a"), py::arg("sketch_b"), py::arg("seed")=DEFAULT_SEED,
-                 "Returns a list with {lower_bound, estimate, upper_bound} of the Jaccard similarity between sketches")
-     .def_static("exactly_equal", &theta_jaccard_similarity::exactly_equal<const theta_sketch&, const theta_sketch&>,
-                 py::arg("sketch_a"), py::arg("sketch_b"), py::arg("seed")=DEFAULT_SEED,
-                 "Returns True if sketch_a and sketch_b are equivalent, otherwise False")
-     .def_static("similarity_test", &theta_jaccard_similarity::similarity_test<const theta_sketch&, const theta_sketch&>,
-                 py::arg("actual"), py::arg("expected"), py::arg("threshold"), py::arg("seed")=DEFAULT_SEED,
-                 "Tests similarity of an actual sketch against an expected sketch. Computers the lower bound of the Jaccard "
-                 "index J_{LB} of the actual and expected sketches. If J_{LB} >= threshold, then the sketches are considered "
-                 "to be similar sith a confidence of 97.7% and returns True, otherwise False.")
-     .def_static("dissimilarity_test", &theta_jaccard_similarity::dissimilarity_test<const theta_sketch&, const theta_sketch&>,
-                 py::arg("actual"), py::arg("expected"), py::arg("threshold"), py::arg("seed")=DEFAULT_SEED,
-                 "Tests dissimilarity of an actual sketch against an expected sketch. Computers the lower bound of the Jaccard "
-                 "index J_{UB} of the actual and expected sketches. If J_{UB} <= threshold, then the sketches are considered "
-                 "to be dissimilar sith a confidence of 97.7% and returns True, otherwise False.")            
+    .def_static(
+        "jaccard",
+        [](const theta_sketch& sketch_a, const theta_sketch& sketch_b, uint64_t seed) {
+          return theta_jaccard_similarity::jaccard(sketch_a, sketch_b, seed);
+        },
+        py::arg("sketch_a"), py::arg("sketch_b"), py::arg("seed")=DEFAULT_SEED,
+        "Returns a list with {lower_bound, estimate, upper_bound} of the Jaccard similarity between sketches"
+    )
+    .def_static(
+        "exactly_equal",
+        &theta_jaccard_similarity::exactly_equal<const theta_sketch&, const theta_sketch&>,
+        py::arg("sketch_a"), py::arg("sketch_b"), py::arg("seed")=DEFAULT_SEED,
+        "Returns True if sketch_a and sketch_b are equivalent, otherwise False"
+    )
+    .def_static(
+        "similarity_test",
+        &theta_jaccard_similarity::similarity_test<const theta_sketch&, const theta_sketch&>,
+        py::arg("actual"), py::arg("expected"), py::arg("threshold"), py::arg("seed")=DEFAULT_SEED,
+        "Tests similarity of an actual sketch against an expected sketch. Computers the lower bound of the Jaccard "
+        "index J_{LB} of the actual and expected sketches. If J_{LB} >= threshold, then the sketches are considered "
+        "to be similar with a confidence of 97.7% and returns True, otherwise False.")
+    .def_static(
+        "dissimilarity_test",
+        &theta_jaccard_similarity::dissimilarity_test<const theta_sketch&, const theta_sketch&>,
+        py::arg("actual"), py::arg("expected"), py::arg("threshold"), py::arg("seed")=DEFAULT_SEED,
+        "Tests dissimilarity of an actual sketch against an expected sketch. Computers the lower bound of the Jaccard "
+        "index J_{UB} of the actual and expected sketches. If J_{UB} <= threshold, then the sketches are considered "
+        "to be dissimilar with a confidence of 97.7% and returns True, otherwise False."
+    )
   ;     
 }