datasketches 0.1.0

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

@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+void init_hll(py::module& m);
+void init_kll(py::module& m);
+void init_fi(py::module& m);
+void init_cpc(py::module& m);
+void init_theta(py::module& m);
+void init_vo(py::module& m);
+void init_vector_of_kll(py::module& m);
+
+PYBIND11_MODULE(datasketches, m) {
+  init_hll(m);
+  init_kll(m);
+  init_fi(m);
+  init_cpc(m);
+  init_theta(m);
+  init_vo(m);
+  init_vector_of_kll(m);
+}

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

@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "frequent_items_sketch.hpp"
+
+#include <pybind11/pybind11.h>
+#include <sstream>
+
+namespace py = pybind11;
+
+namespace datasketches {
+namespace python {
+
+template<typename T>
+frequent_items_sketch<T> fi_sketch_deserialize(py::bytes skBytes) {
+  std::string skStr = skBytes; // implicit cast  
+  return frequent_items_sketch<T>::deserialize(skStr.c_str(), skStr.length());
+}
+
+template<typename T>
+py::object fi_sketch_serialize(const frequent_items_sketch<T>& sk) {
+  auto serResult = sk.serialize();
+  return py::bytes((char*)serResult.data(), serResult.size());
+}
+
+// maybe possible to disambiguate the static vs method get_epsilon calls, but
+// this is easier for now
+template<typename T>
+double fi_sketch_get_generic_epsilon(uint8_t lg_max_map_size) {
+  return frequent_items_sketch<T>::get_epsilon(lg_max_map_size);
+}
+
+template<typename T>
+py::list fi_sketch_get_frequent_items(const frequent_items_sketch<T>& sk,
+                                   frequent_items_error_type err_type,
+                                   uint64_t threshold = 0) {
+  if (threshold == 0) { threshold = sk.get_maximum_error(); }
+
+  py::list list;
+  auto items = sk.get_frequent_items(err_type, threshold);
+  for (auto iter = items.begin(); iter != items.end(); ++iter) {
+    py::tuple t = py::make_tuple(iter->get_item(),
+                                 iter->get_estimate(),
+                                 iter->get_lower_bound(),
+                                 iter->get_upper_bound());
+    list.append(t);
+  }
+  return list;
+}
+
+}
+}
+
+namespace dspy = datasketches::python;
+
+template<typename T>
+void bind_fi_sketch(py::module &m, const char* name) {
+  using namespace datasketches;
+
+  py::class_<frequent_items_sketch<T>>(m, name)
+    .def(py::init<uint8_t>(), py::arg("lg_max_k"))
+    .def("__str__", &frequent_items_sketch<T>::to_string, py::arg("print_items")=false,
+         "Produces a string summary of the sketch")
+    .def("to_string", &frequent_items_sketch<T>::to_string, py::arg("print_items")=false,
+         "Produces a string summary of the sketch")
+    .def("update", (void (frequent_items_sketch<T>::*)(const T&, uint64_t)) &frequent_items_sketch<T>::update, py::arg("item"), py::arg("weight")=1,
+         "Updates the sketch with the given string and, optionally, a weight")
+    .def("get_frequent_items", &dspy::fi_sketch_get_frequent_items<T>, py::arg("err_type"), py::arg("threshold")=0)
+    .def("merge", (void (frequent_items_sketch<T>::*)(const frequent_items_sketch<T>&)) &frequent_items_sketch<T>::merge,
+         "Merges the given sketch into this one")
+    .def("is_empty", &frequent_items_sketch<T>::is_empty,
+         "Returns True if the sketch is empty, otherwise False")
+    .def("get_num_active_items", &frequent_items_sketch<T>::get_num_active_items,
+         "Returns the number of active items in the sketch")
+    .def("get_total_weight", &frequent_items_sketch<T>::get_total_weight,
+         "Returns the sum of the weights (frequencies) in the stream seen so far by the sketch")
+    .def("get_estimate", &frequent_items_sketch<T>::get_estimate, py::arg("item"),
+         "Returns the estimate of the weight (frequency) of the given item.\n"
+         "Note: The true frequency of a item would be the sum of the counts as a result of the "
+         "two update functions.")
+    .def("get_lower_bound", &frequent_items_sketch<T>::get_lower_bound, py::arg("item"),
+         "Returns the guaranteed lower bound weight (frequency) of the given item.")
+    .def("get_upper_bound", &frequent_items_sketch<T>::get_upper_bound, py::arg("item"),
+         "Returns the guaranteed upper bound weight (frequency) of the given item.")
+    .def("get_sketch_epsilon", (double (frequent_items_sketch<T>::*)(void) const) &frequent_items_sketch<T>::get_epsilon,
+         "Returns the epsilon value used by the sketch to compute error")
+    .def_static("get_epsilon_for_lg_size", &dspy::fi_sketch_get_generic_epsilon<T>, py::arg("lg_max_map_size"),
+         "Returns the epsilon value used to compute a priori error for a given log2(max_map_size)")
+    .def_static("get_apriori_error", &frequent_items_sketch<T>::get_apriori_error, py::arg("lg_max_map_size"), py::arg("estimated_total_weight"),
+         "Returns the estimated a priori error given the max_map_size for the sketch and the estimated_total_stream_weight.")
+    .def("get_serialized_size_bytes", &frequent_items_sketch<T>::get_serialized_size_bytes,
+         "Computes the size needed to serialize the current state of the sketch. This can be expensive since every item needs to be looked at.")
+    .def("serialize", &dspy::fi_sketch_serialize<T>, "Serializes the sketch into a bytes object")
+    .def_static("deserialize", &dspy::fi_sketch_deserialize<T>, "Reads a bytes object and returns the corresponding frequent_strings_sketch")
+    ;
+}
+
+void init_fi(py::module &m) {
+  using namespace datasketches;
+
+  py::enum_<frequent_items_error_type>(m, "frequent_items_error_type")
+    .value("NO_FALSE_POSITIVES", NO_FALSE_POSITIVES)
+    .value("NO_FALSE_NEGATIVES", NO_FALSE_NEGATIVES)
+    .export_values();
+
+  bind_fi_sketch<std::string>(m, "frequent_strings_sketch");
+}

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

@@ -0,0 +1,136 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "hll.hpp"
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+namespace datasketches {
+namespace python {
+
+hll_sketch hll_sketch_deserialize(py::bytes skBytes) {
+  std::string skStr = skBytes; // implicit cast  
+  return hll_sketch::deserialize(skStr.c_str(), skStr.length());
+}
+
+py::object hll_sketch_serialize_compact(const hll_sketch& sk) {
+  auto serResult = sk.serialize_compact();
+  return py::bytes((char*)serResult.data(), serResult.size());
+}
+
+py::object hll_sketch_serialize_updatable(const hll_sketch& sk) {
+  auto serResult = sk.serialize_updatable();
+  return py::bytes((char*)serResult.data(), serResult.size());
+}
+
+}
+}
+
+namespace dspy = datasketches::python;
+
+void init_hll(py::module &m) {
+  using namespace datasketches;
+
+  py::enum_<target_hll_type>(m, "tgt_hll_type", "Target HLL flavor")
+    .value("HLL_4", HLL_4)
+    .value("HLL_6", HLL_6)
+    .value("HLL_8", HLL_8)
+    .export_values();
+
+  py::class_<hll_sketch>(m, "hll_sketch")
+    .def(py::init<int>(), py::arg("lg_k"))
+    .def(py::init<int, target_hll_type>(), py::arg("lg_k"), py::arg("tgt_type"))
+    .def(py::init<int, target_hll_type, bool>(), py::arg("lg_k"), py::arg("tgt_type"), py::arg("start_max_size")=false)
+    .def_static("deserialize", &dspy::hll_sketch_deserialize,
+         "Reads a bytes object and returns the corresponding hll_sketch")
+    .def("serialize_compact", &dspy::hll_sketch_serialize_compact,
+         "Serializes the sketch into a bytes object, compressiong the exception table if HLL_4")
+    .def("serialize_updatable", &dspy::hll_sketch_serialize_updatable,
+         "Serializes the sketch into a bytes object")
+    .def("__str__", (std::string (hll_sketch::*)(bool,bool,bool,bool) const) &hll_sketch::to_string,
+         py::arg("summary")=true, py::arg("detail")=false, py::arg("aux_detail")=false, py::arg("all")=false,
+         "Produces a string summary of the sketch")
+    .def("to_string", (std::string (hll_sketch::*)(bool,bool,bool,bool) const) &hll_sketch::to_string,
+         py::arg("summary")=true, py::arg("detail")=false, py::arg("aux_detail")=false, py::arg("all")=false,
+         "Produces a string summary of the sketch")
+    .def_property_readonly("lg_config_k", &hll_sketch::get_lg_config_k, "Configured lg_k value for the sketch")
+    .def_property_readonly("tgt_type", &hll_sketch::get_target_type, "Returns the HLL type (4, 6, or 8) when in estimation mode")
+    .def("get_estimate", &hll_sketch::get_estimate,
+         "Estimate of the distinct count of the input stream")
+    .def("get_lower_bound", &hll_sketch::get_lower_bound, py::arg("num_std_devs"),
+         "Returns the approximate lower error bound given the specified number of standard deviations in {1, 2, 3}")
+    .def("get_upper_bound", &hll_sketch::get_upper_bound, py::arg("num_std_devs"),
+         "Returns the approximate upper error bound given the specified number of standard deviations in {1, 2, 3}")
+    .def("is_compact", &hll_sketch::is_compact,
+         "True if the sketch is compact, otherwise False")
+    .def("is_empty", &hll_sketch::is_empty,
+         "True if the sketch is empty, otherwise False")
+    .def("get_updatable_serialization_bytes", &hll_sketch::get_updatable_serialization_bytes,
+         "Returns the size of the serialized sketch")
+    .def("get_compact_serialization_bytes", &hll_sketch::get_compact_serialization_bytes,
+         "Returns the size of the serialized sketch when compressing the exception table if HLL_4")
+    .def("reset", &hll_sketch::reset,
+         "Resets the sketch to the empty state in coupon colleciton mode")
+    .def("update", (void (hll_sketch::*)(int64_t)) &hll_sketch::update, py::arg("datum"),
+         "Updates the sketch with the given integral value")
+    .def("update", (void (hll_sketch::*)(double)) &hll_sketch::update, py::arg("datum"),
+         "Updates the sketch with the given floating point value")
+    .def("update", (void (hll_sketch::*)(const std::string&)) &hll_sketch::update, py::arg("datum"),
+         "Updates the sketch with the given string value")
+    .def_static("get_max_updatable_serialization_bytes", &hll_sketch::get_max_updatable_serialization_bytes,
+         py::arg("lg_k"), py::arg("tgt_type"),
+         "Provides a likely upper bound on serialization size for the given paramters")
+    .def_static("get_rel_err", &hll_sketch::get_rel_err,
+         py::arg("upper_bound"), py::arg("unioned"), py::arg("lg_k"), py::arg("num_std_devs"),
+         "Retuns the a priori relative error bound for the given parameters")
+    ;
+
+  py::class_<hll_union>(m, "hll_union")
+    .def(py::init<int>(), py::arg("lg_max_k"))
+    .def_property_readonly("lg_config_k", &hll_union::get_lg_config_k, "Configured lg_k value for the union")
+    .def_property_readonly("tgt_type", &hll_union::get_target_type, "Returns the HLL type (4, 6, or 8) when in estimation mode")
+    .def("get_estimate", &hll_union::get_estimate,
+         "Estimate of the distinct count of the input stream")
+    .def("get_lower_bound", &hll_union::get_lower_bound, py::arg("num_std_devs"),
+         "Returns the approximate lower error bound given the specified number of standard deviations in {1, 2, 3}")
+    .def("get_upper_bound", &hll_union::get_upper_bound, py::arg("num_std_devs"),
+         "Returns the approximate upper error bound given the specified number of standard deviations in {1, 2, 3}")
+    .def("is_compact", &hll_union::is_compact,
+         "True if the union is compact, otherwise False")
+    .def("is_empty", &hll_union::is_empty,
+         "True if the union is empty, otherwise False")    
+    .def("reset", &hll_union::reset,
+         "Resets the union to the empty state")
+    .def("get_result", &hll_union::get_result, py::arg("tgt_type")=HLL_4,
+         "Returns a sketch of the target type representing the current union state")
+    .def<void (hll_union::*)(const hll_sketch&)>("update", &hll_union::update, py::arg("sketch"),
+         "Updates the union with the given HLL sketch")
+    .def<void (hll_union::*)(int64_t)>("update", &hll_union::update, py::arg("datum"),
+         "Updates the union with the given integral value")
+    .def<void (hll_union::*)(double)>("update", &hll_union::update, py::arg("datum"),
+         "Updates the union with the given floating point value")
+    .def<void (hll_union::*)(const std::string&)>("update", &hll_union::update, py::arg("datum"),
+         "Updates the union with the given string value")
+    .def_static("get_rel_err", &hll_union::get_rel_err,
+         py::arg("upper_bound"), py::arg("unioned"), py::arg("lg_k"), py::arg("num_std_devs"),
+         "Retuns the a priori relative error bound for the given parameters")
+    ;
+}

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

@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "kll_sketch.hpp"
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include <sstream>
+#include <vector>
+
+namespace py = pybind11;
+
+namespace datasketches {
+
+namespace python {
+
+template<typename T>
+kll_sketch<T> kll_sketch_deserialize(py::bytes skBytes) {
+  std::string skStr = skBytes; // implicit cast  
+  return kll_sketch<T>::deserialize(skStr.c_str(), skStr.length());
+}
+
+template<typename T>
+py::object kll_sketch_serialize(const kll_sketch<T>& sk) {
+  auto serResult = sk.serialize();
+  return py::bytes((char*)serResult.data(), serResult.size());
+}
+
+// maybe possible to disambiguate the static vs method rank error calls, but
+// this is easier for now
+template<typename T>
+double kll_sketch_generic_normalized_rank_error(uint16_t k, bool pmf) {
+  return kll_sketch<T>::get_normalized_rank_error(k, pmf);
+}
+
+template<typename T>
+py::list kll_sketch_get_quantiles(const kll_sketch<T>& sk,
+                                  std::vector<double>& fractions) {
+  size_t nQuantiles = fractions.size();
+  auto result = sk.get_quantiles(&fractions[0], nQuantiles);
+
+  // returning as std::vector<> would copy values to a list anyway
+  py::list list(nQuantiles);
+  for (size_t i = 0; i < nQuantiles; ++i) {
+      list[i] = result[i];
+  }
+
+  return list;
+}
+
+template<typename T>
+py::list kll_sketch_get_pmf(const kll_sketch<T>& sk,
+                            std::vector<T>& split_points) {
+  size_t nPoints = split_points.size();
+  auto result = sk.get_PMF(&split_points[0], nPoints);
+
+  py::list list(nPoints + 1);
+  for (size_t i = 0; i <= nPoints; ++i) {
+    list[i] = result[i];
+  }
+
+  return list;
+}
+
+template<typename T>
+py::list kll_sketch_get_cdf(const kll_sketch<T>& sk,
+                            std::vector<T>& split_points) {
+  size_t nPoints = split_points.size();
+  auto result = sk.get_CDF(&split_points[0], nPoints);
+
+  py::list list(nPoints + 1);
+  for (size_t i = 0; i <= nPoints; ++i) {
+    list[i] = result[i];
+  }
+
+  return list;
+}
+
+template<typename T>
+void kll_sketch_update(kll_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>
+void bind_kll_sketch(py::module &m, const char* name) {
+  using namespace datasketches;
+
+  py::class_<kll_sketch<T>>(m, name)
+    .def(py::init<uint16_t>(), py::arg("k")=kll_sketch<T>::DEFAULT_K)
+    .def(py::init<const kll_sketch<T>&>())
+    .def("update", (void (kll_sketch<T>::*)(const T&)) &kll_sketch<T>::update, py::arg("item"),
+         "Updates the sketch with the given value")
+    .def("update", &dspy::kll_sketch_update<T>, py::arg("array"),
+         "Updates the sketch with the values in the given array")
+    .def("merge", (void (kll_sketch<T>::*)(const kll_sketch<T>&)) &kll_sketch<T>::merge, py::arg("sketch"),
+         "Merges the provided sketch into the this one")
+    .def("__str__", &kll_sketch<T>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
+         "Produces a string summary of the sketch")
+    .def("to_string", &kll_sketch<T>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
+         "Produces a string summary of the sketch")
+    .def("is_empty", &kll_sketch<T>::is_empty,
+         "Returns True if the sketch is empty, otherwise False")
+    .def("get_n", &kll_sketch<T>::get_n,
+         "Returns the length of the input stream")
+    .def("get_num_retained", &kll_sketch<T>::get_num_retained,
+         "Returns the number of retained items (samples) in the sketch")
+    .def("is_estimation_mode", &kll_sketch<T>::is_estimation_mode,
+         "Returns True if the sketch is in estimation mode, otherwise False")
+    .def("get_min_value", &kll_sketch<T>::get_min_value,
+         "Returns the minimum value from the stream. If empty, kll_floats_sketch retursn nan; kll_ints_sketch throws a RuntimeError")
+    .def("get_max_value", &kll_sketch<T>::get_max_value,
+         "Returns the maximum value from the stream. If empty, kll_floats_sketch retursn nan; kll_ints_sketch throws a RuntimeError")
+    .def("get_quantile", &kll_sketch<T>::get_quantile, py::arg("fraction"),
+         "Returns an approximation to the value of the data item "
+         "that would be preceded by the given fraction of a hypothetical sorted "
+         "version of the input stream so far.\n"
+         "Note that this method has a fairly large overhead (microseconds instead of nanoseconds) "
+         "so it should not be called multiple times to get different quantiles from the same "
+         "sketch. Instead use get_quantiles(), which pays the overhead only once.\n"
+         "For kll_floats_sketch: if the sketch is empty this returns nan. "
+         "For kll_ints_sketch: if the sketch is empty this throws a RuntimeError.")
+    .def("get_quantiles", &dspy::kll_sketch_get_quantiles<T>, py::arg("fractions"),
+         "This is a more efficient multiple-query version of get_quantile().\n"
+         "This returns an array that could have been generated by using get_quantile() for each "
+         "fractional rank separately, but would be very inefficient. "
+         "This method incurs the internal set-up overhead once and obtains multiple quantile values in "
+         "a single query. It is strongly recommend that this method be used instead of multiple calls "
+         "to get_quantile().\n"
+         "If the sketch is empty this returns an empty vector.")
+    .def("get_rank", &kll_sketch<T>::get_rank, py::arg("value"),
+         "Returns an approximation to the normalized (fractional) 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"
+         "If the sketch is empty this returns nan.")
+    .def("get_pmf", &dspy::kll_sketch_get_pmf<T>, py::arg("split_points"),
+         "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"
+         "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"
+         "It is not necessary to include either the min or max values in these split points.")
+    .def("get_cdf", &dspy::kll_sketch_get_cdf<T>, py::arg("split_points"),
+         "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"
+         "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"
+         "It is not necessary to include either the min or max values in these split points.")
+    .def("normalized_rank_error", (double (kll_sketch<T>::*)(bool) const) &kll_sketch<T>::get_normalized_rank_error,
+         py::arg("as_pmf"),
+         "Gets the normalized rank error for this sketch.\n"
+         "If pmf is True, returns the 'double-sided' normalized rank error for the get_PMF() function.\n"
+         "Otherwise, it is the 'single-sided' normalized rank error for all the other queries.\n"
+         "Constants were derived as the best fit to 99 percentile empirically measured max error in thousands of trials")
+    .def_static("get_normalized_rank_error", &dspy::kll_sketch_generic_normalized_rank_error<T>,
+         py::arg("k"), py::arg("as_pmf"),
+         "Gets the normalized rank error given parameters k and the pmf flag.\n"
+         "If pmf is True, returns the 'double-sided' normalized rank error for the get_PMF() function.\n"
+         "Otherwise, it is the 'single-sided' normalized rank error for all the other queries.\n"
+         "Constants were derived as the best fit to 99 percentile empirically measured max error in thousands of trials")
+    .def("serialize", &dspy::kll_sketch_serialize<T>, "Serailizes the sketch into a bytes object")
+    .def_static("deserialize", &dspy::kll_sketch_deserialize<T>, "Deserializes the sketch from a bytes object")
+    ;
+}
+
+void init_kll(py::module &m) {
+  bind_kll_sketch<int>(m, "kll_ints_sketch");
+  bind_kll_sketch<float>(m, "kll_floats_sketch");
+}