datasketches 0.3.1 → 0.4.0

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

@@ -1,134 +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 "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<uint8_t>(), py::arg("lg_k"))
-    .def(py::init<uint8_t, target_hll_type>(), py::arg("lg_k"), py::arg("tgt_type"))
-    .def(py::init<uint8_t, 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<uint8_t>(), 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_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

@@ -1,210 +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 "kll_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>
-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>& ranks,
-                                  bool inclusive) {
-  size_t nQuantiles = ranks.size();
-  auto result = sk.get_quantiles(ranks.data(), nQuantiles, inclusive);
-  // 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,
-                            bool inclusive) {
-  size_t nPoints = split_points.size();
-  auto result = sk.get_PMF(split_points.data(), nPoints, inclusive);
-  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,
-                            bool inclusive) {
-  size_t nPoints = split_points.size();
-  auto result = sk.get_CDF(split_points.data(), nPoints, inclusive);
-  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_constants::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_k", &kll_sketch<T>::get_k,
-         "Returns the configured parameter k")
-    .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_item,
-         "Returns the minimum value from the stream. If empty, kll_floats_sketch returns nan; kll_ints_sketch throws a RuntimeError")
-    .def("get_max_value", &kll_sketch<T>::get_max_item,
-         "Returns the maximum value from the stream. If empty, kll_floats_sketch returns nan; kll_ints_sketch throws a RuntimeError")
-    .def("get_quantile", &kll_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 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("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", &kll_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::kll_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::kll_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("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>, "Serializes 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");
-  bind_kll_sketch<double>(m, "kll_doubles_sketch");
-}

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

@@ -1,68 +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 "kolmogorov_smirnov.hpp"
-#include "kll_sketch.hpp"
-#include "quantiles_sketch.hpp"
-
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-void init_kolmogorov_smirnov(py::module &m) {
-  using namespace datasketches;
-
-  m.def("ks_test", &kolmogorov_smirnov::test<kll_sketch<int>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between kll_ints_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-  m.def("ks_test", &kolmogorov_smirnov::test<kll_sketch<float>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between kll_floats_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-  m.def("ks_test", &kolmogorov_smirnov::test<kll_sketch<double>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between kll_doubles_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-
-  m.def("ks_test", &kolmogorov_smirnov::test<quantiles_sketch<int>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between quantiles_ints_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-  m.def("ks_test", &kolmogorov_smirnov::test<quantiles_sketch<float>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between quantiles_floats_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-  m.def("ks_test", &kolmogorov_smirnov::test<quantiles_sketch<double>>, py::arg("sk_1"), py::arg("sk_2"), py::arg("p"),
-    "Performs the Kolmogorov-Smirnov Test between quantiles_doubles_sketches.\n"
-    "Note: if the given sketches have insufficient data or if the sketch sizes are too small, "
-    "this will return false.\n"
-    "Returns True if we can reject the null hypothesis (that the sketches reflect the same underlying "
-    "distribution) using the provided p-value, otherwise False.");
-}

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

@@ -1,111 +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) {
-  py::class_<datasketches::py_object_serde, datasketches::PyObjectSerDe /* <--- trampoline*/>(m, "PyObjectSerDe")
-    .def(py::init<>())
-    .def("get_size", &datasketches::py_object_serde::get_size, py::arg("item"),
-        "Returns the size in bytes of an item")
-    .def("to_bytes", &datasketches::py_object_serde::to_bytes, py::arg("item"),
-        "Retuns a bytes object with a serialized version of an item")
-    .def("from_bytes", &datasketches::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