datasketches 0.3.2 → 0.4.1

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

@@ -1,112 +0,0 @@
-/*
- * 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 <cstring>
-#include "memory_operations.hpp"
-
-#include "py_serde.hpp"
-
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-void init_serde(py::module& m) {
-  using namespace datasketches;
-  py::class_<py_object_serde, PyObjectSerDe /* <--- trampoline*/>(m, "PyObjectSerDe")
-    .def(py::init<>())
-    .def("get_size", &py_object_serde::get_size, py::arg("item"),
-        "Returns the size in bytes of an item")
-    .def("to_bytes", &py_object_serde::to_bytes, py::arg("item"),
-        "Retuns a bytes object with a serialized version of an item")
-    .def("from_bytes", &py_object_serde::from_bytes, py::arg("data"), py::arg("offset"),
-        "Reads a bytes object starting from the given offest and returns a tuple of the reconstructed "
-        "object and the number of additional bytes read")
-    ;
-}    
-
-namespace datasketches {
-  size_t py_object_serde::size_of_item(const py::object& item) const {
-    return get_size(item);
-  }
-
-  size_t py_object_serde::serialize(void* ptr, size_t capacity, const py::object* items, unsigned num) const {
-    size_t bytes_written = 0;
-    py::gil_scoped_acquire acquire;
-    for (unsigned i = 0; i < num; ++i) {
-      std::string bytes = to_bytes(items[i]); // implicit cast from py::bytes
-      check_memory_size(bytes_written + bytes.size(), capacity);
-      memcpy(ptr, bytes.c_str(), bytes.size());
-      ptr = static_cast<char*>(ptr) + bytes.size();
-      bytes_written += bytes.size();
-    }
-    py::gil_scoped_release release;
-    return bytes_written;
-  }
-
-  size_t py_object_serde::deserialize(const void* ptr, size_t capacity, py::object* items, unsigned num) const {
-    size_t bytes_read = 0;
-    unsigned i = 0;
-    bool failure = false;
-    bool error_from_python = false;
-    py::gil_scoped_acquire acquire;
-
-    // copy data into bytes only once
-    py::bytes bytes(static_cast<const char*>(ptr), capacity);
-    for (; i < num && !failure; ++i) {
-      py::tuple bytes_and_len;
-      try {
-        bytes_and_len = from_bytes(bytes, bytes_read);
-      } catch (py::error_already_set &e) {
-        failure = true;
-        error_from_python = true;
-        break;
-      }
-
-      size_t length = py::cast<size_t>(bytes_and_len[1]);
-      if (bytes_read + length > capacity) {
-        bytes_read += length; // use this value to report the error
-        failure = true;
-        break;
-      }
-      
-      new (&items[i]) py::object(py::cast<py::object>(bytes_and_len[0]));
-      ptr = static_cast<const char*>(ptr) + length;
-      bytes_read += length;
-    }
-
-    if (failure) {
-      // clean up what we've allocated
-      for (unsigned j = 0; j < i; ++j) {
-        items[j].dec_ref();
-      }
-
-      if (error_from_python) {
-        throw py::value_error("Error reading value in from_bytes");
-      } else {
-        // this next call will throw
-        check_memory_size(bytes_read, capacity);
-      }
-    }
-
-    py::gil_scoped_release release;
-    return bytes_read;
-  }
-
-
-} // namespace datasketches

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

@@ -1,155 +0,0 @@
-/*
- * 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 "py_object_lt.hpp"
-#include "py_object_ostream.hpp"
-#include "quantile_conditional.hpp"
-#include "quantiles_sketch.hpp"
-
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <pybind11/numpy.h>
-#include <vector>
-#include <stdexcept>
-
-namespace py = pybind11;
-
-template<typename T, typename C>
-void bind_quantiles_sketch(py::module &m, const char* name) {
-  using namespace datasketches;
-
-  auto quantiles_class = py::class_<quantiles_sketch<T, C>>(m, name)
-    .def(py::init<uint16_t>(), py::arg("k")=quantiles_constants::DEFAULT_K)
-    .def(py::init<const quantiles_sketch<T, C>&>())
-    .def(
-        "update",
-        static_cast<void (quantiles_sketch<T, C>::*)(const T&)>(&quantiles_sketch<T, C>::update),
-        py::arg("item"),
-        "Updates the sketch with the given value"
-    )
-    .def("merge", (void (quantiles_sketch<T, C>::*)(const quantiles_sketch<T, C>&)) &quantiles_sketch<T, C>::merge, py::arg("sketch"),
-         "Merges the provided sketch into this one")
-    .def("__str__", &quantiles_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", &quantiles_sketch<T, C>::to_string, py::arg("print_levels")=false, py::arg("print_items")=false,
-         "Produces a string summary of the sketch")
-    .def("is_empty", &quantiles_sketch<T, C>::is_empty,
-         "Returns True if the sketch is empty, otherwise False")
-    .def("get_k", &quantiles_sketch<T, C>::get_k,
-         "Returns the configured parameter k")
-    .def("get_n", &quantiles_sketch<T, C>::get_n,
-         "Returns the length of the input stream")
-    .def("get_num_retained", &quantiles_sketch<T, C>::get_num_retained,
-         "Returns the number of retained items (samples) in the sketch")
-    .def("is_estimation_mode", &quantiles_sketch<T, C>::is_estimation_mode,
-         "Returns True if the sketch is in estimation mode, otherwise False")
-    .def("get_min_value", &quantiles_sketch<T, C>::get_min_item,
-         "Returns the minimum value from the stream. If empty, quantiles_floats_sketch returns nan; quantiles_ints_sketch throws a RuntimeError")
-    .def("get_max_value", &quantiles_sketch<T, C>::get_max_item,
-         "Returns the maximum value from the stream. If empty, quantiles_floats_sketch returns nan; quantiles_ints_sketch throws a RuntimeError")
-    .def("get_quantile", &quantiles_sketch<T, C>::get_quantile, py::arg("rank"), py::arg("inclusive")=false,
-         "Returns an approximation to the data value "
-         "associated with the given rank in a hypothetical sorted "
-         "version of the input stream so far.\n"
-         "For quantiles_floats_sketch: if the sketch is empty this returns nan. "
-         "For quantiles_ints_sketch: if the sketch is empty this throws a RuntimeError.")
-    .def(
-        "get_quantiles",
-        [](const quantiles_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", &quantiles_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 quantiles_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"
-        "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",
-        [](const quantiles_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"
-        "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",
-        static_cast<double (quantiles_sketch<T, C>::*)(bool) const>(&quantiles_sketch<T, C>::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",
-        [](uint16_t k, bool pmf) { return quantiles_sketch<T, C>::get_normalized_rank_error(k, pmf); },
-        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("__iter__", [](const quantiles_sketch<T, C>& s) { return py::make_iterator(s.begin(), s.end()); });
-
-    add_serialization<T>(quantiles_class);
-    add_vector_update<T>(quantiles_class);
-}
-
-void init_quantiles(py::module &m) {
-  bind_quantiles_sketch<int, std::less<int>>(m, "quantiles_ints_sketch");
-  bind_quantiles_sketch<float, std::less<float>>(m, "quantiles_floats_sketch");
-  bind_quantiles_sketch<double, std::less<double>>(m, "quantiles_doubles_sketch");
-  bind_quantiles_sketch<py::object, py_object_lt>(m, "quantiles_items_sketch");
-}

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

@@ -1,154 +0,0 @@
-/*
- * 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 "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 <vector>
-#include <stdexcept>
-
-namespace py = pybind11;
-
-template<typename T, typename C>
-void bind_req_sketch(py::module &m, const char* name) {
-  using namespace datasketches;
-
-  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, 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, 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

@@ -1,166 +0,0 @@
-/*
- * 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>
-#include <pybind11/stl.h>
-
-#include "theta_sketch.hpp"
-#include "theta_union.hpp"
-#include "theta_intersection.hpp"
-#include "theta_a_not_b.hpp"
-#include "theta_jaccard_similarity.hpp"
-#include "common_defs.hpp"
-
-namespace py = pybind11;
-
-void init_theta(py::module &m) {
-  using namespace datasketches;
-
-  py::class_<theta_sketch>(m, "theta_sketch")
-    .def("__str__", &theta_sketch::to_string, py::arg("print_items")=false,
-         "Produces a string summary of the sketch")
-    .def("to_string", &theta_sketch::to_string, py::arg("print_items")=false,
-         "Produces a string summary of the sketch")
-    .def("is_empty", &theta_sketch::is_empty,
-         "Returns True if the sketch is empty, otherwise False")
-    .def("get_estimate", &theta_sketch::get_estimate,
-         "Estimate of the distinct count of the input stream")
-    .def("get_upper_bound", &theta_sketch::get_upper_bound, py::arg("num_std_devs"),
-         "Returns an approximate upper bound on the estimate at standard deviations in {1, 2, 3}")
-    .def("get_lower_bound", &theta_sketch::get_lower_bound, py::arg("num_std_devs"),
-         "Returns an approximate lower bound on the estimate at standard deviations in {1, 2, 3}")
-    .def("is_estimation_mode", &theta_sketch::is_estimation_mode,
-         "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,
-         "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([](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")
-    .def("update", (void (update_theta_sketch::*)(double)) &update_theta_sketch::update, py::arg("datum"),
-         "Updates the sketch with the given floating point value")
-    .def("update", (void (update_theta_sketch::*)(const std::string&)) &update_theta_sketch::update, py::arg("datum"),
-         "Updates the sketch with the given string")
-    .def("compact", &update_theta_sketch::compact, py::arg("ordered")=true,
-         "Returns a compacted form of the sketch, optionally sorting it")
-  ;
-
-  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",
-        [](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"
-    );
-
-  py::class_<theta_union>(m, "theta_union")
-    .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,
-         "Returns the sketch corresponding to the union result")
-  ;
-
-  py::class_<theta_intersection>(m, "theta_intersection")
-    .def(py::init<uint64_t>(), py::arg("seed")=DEFAULT_SEED)
-    .def(py::init<const theta_intersection&>())
-    .def("update", &theta_intersection::update<const theta_sketch&>, py::arg("sketch"),
-         "Intersections the provided sketch with the current intersection state")
-    .def("get_result", &theta_intersection::get_result, py::arg("ordered")=true,
-         "Returns the sketch corresponding to the intersection result")
-    .def("has_result", &theta_intersection::has_result,
-         "Returns True if the intersection has a valid result, otherwise False")
-  ;
-
-  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 result of applying the A-not-B operation on the given inputs"
-    )
-  ;
-  
-  py::class_<theta_jaccard_similarity>(m, "theta_jaccard_similarity")
-    .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."
-    )
-  ;     
-}