datasketches 0.3.2 → 0.4.0

data/vendor/datasketches-cpp/python/datasketches/KernelFunction.py

@@ -1,35 +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.
-
-import numpy as np
-
-from _datasketches import KernelFunction
-
-# This file provides an example Python Kernel Function implementation.
-#
-# Each implementation must extend the KernelFunction class
-# and define the __call__ method
-
-# Implements a basic Gaussian Kernel
-class GaussianKernel(KernelFunction):
-  def __init__(self, bandwidth: float=1.0):
-    KernelFunction.__init__(self)
-    self._bw = bandwidth
-    self._scale = -0.5 * (bandwidth ** -2)
-
-  def __call__(self, a: np.array, b: np.array) -> float:
-    return np.exp(self._scale * np.linalg.norm(a - b)**2)

data/vendor/datasketches-cpp/python/datasketches/PySerDe.py

@@ -1,110 +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.
-
-from _datasketches import PyObjectSerDe
-
-import struct
-
-# This file provides several Python SerDe implementation examples.
-#
-# Each implementation must extend the PyObjectSerDe class and define
-# three methods:
-#   * get_size(item) returns an int of the number of bytes needed to
-#     serialize the given item
-#   * to_bytes(item) returns a bytes object representing a serialized
-#     version of the given item
-#   * from_bytes(data, offset) takes a bytes object (data) and an offset
-#     indicating where in the data array to start reading. The method
-#     returns a tuple with the newly reconstructed object and the
-#     total number of bytes beyond the offset read from the input data.
-
-# Implements a simple string-encoding scheme where a string is
-# written as <num_bytes> <string_contents>, with no null termination.
-# This format allows pre-allocating each string, at the cost of
-# additional storage. Using this format, the serialized string consumes
-# 4 + len(item) bytes.
-class PyStringsSerDe(PyObjectSerDe):
-  def get_size(self, item):
-    return int(4 + len(item))
-
-  def to_bytes(self, item: str):
-    b = bytearray()
-    b.extend(len(item).to_bytes(4, 'little'))
-    b.extend(map(ord,item))
-    return bytes(b)
-
-  def from_bytes(self, data: bytes, offset: int):
-    num_chars = int.from_bytes(data[offset:offset+3], 'little')
-    if (num_chars < 0 or num_chars > offset + len(data)):
-        raise IndexError(f'num_chars read must be non-negative and not larger than the buffer. Found {num_chars}')
-    str = data[offset+4:offset+4+num_chars].decode()
-    return (str, 4+num_chars)
-
-# Implements an integer encoding scheme where each integer is written
-# as a 32-bit (4 byte) little-endian value.
-class PyIntsSerDe(PyObjectSerDe):
-  def get_size(self, item):
-    return int(4)
-
-  def to_bytes(self, item):
-    return struct.pack('<i', item)
-
-  def from_bytes(self, data: bytes, offset: int):
-    val = struct.unpack_from('<i', data, offset)[0]
-    return (val, 4)
-
-
-# Implements an integer encoding scheme where each integer is written
-# as a 64-bit (8 byte) little-endian value.
-class PyLongsSerDe(PyObjectSerDe):
-  def get_size(self, item):
-    return int(8)
-
-  def to_bytes(self, item):
-    return struct.pack('<l', item)
-
-  def from_bytes(self, data: bytes, offset: int):
-    val = struct.unpack_from('<l', data, offset)[0]
-    return (val, 8)
-
-
-# Implements a floating point encoding scheme where each value is written
-# as a 32-bit floating point value.
-class PyFloatsSerDe(PyObjectSerDe):
-  def get_size(self, item):
-    return int(4)
-
-  def to_bytes(self, item):
-    return struct.pack('<f', item)
-
-  def from_bytes(self, data: bytes, offset: int):
-    val = struct.unpack_from('<f', data, offset)[0]
-    return (val, 4)
-
-
-# Implements a floating point encoding scheme where each value is written
-# as a 64-bit floating point value.
-class PyDoublesSerDe(PyObjectSerDe):
-  def get_size(self, item):
-    return int(8)
-
-  def to_bytes(self, item):
-    return struct.pack('<d', item)
-
-  def from_bytes(self, data: bytes, offset: int):
-    val = struct.unpack_from('<d', data, offset)[0]
-    return (val, 8)

data/vendor/datasketches-cpp/python/datasketches/TuplePolicy.py

@@ -1,77 +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.
-
-import sys
-
-from _datasketches import TuplePolicy
-
-# This file provides an example Python Tuple Policy implementation.
-#
-# Each implementation must extend the PyTuplePolicy class and define
-# two methods:
-#   * create_summary() returns a new Summary object
-#   * update_summary(summary, update) applies the relevant policy to update the
-#     provided summary with the data in update.
-#   * __call__ may be similar to update_summary but allows a different
-#     implementation for set operations (union and intersection)
-
-# Implements an accumulator summary policy, where new values are
-# added to the existing value.
-class AccumulatorPolicy(TuplePolicy):
-  def __init__(self):
-    TuplePolicy.__init__(self)
-
-  def create_summary(self) -> int:
-    return int(0)
-
-  def update_summary(self, summary: int, update: int) -> int:
-    summary += update
-    return summary
-
-  def __call__(self, summary: int, update: int) -> int:
-    summary += update
-    return summary
-
-
-# Implements a MAX rule, where the largest integer value is always kept
-class MaxIntPolicy(TuplePolicy):
-  def __init__(self):
-    TuplePolicy.__init__(self)
-
-  def create_summary(self) -> int:
-    return int(-sys.maxsize-1)
-
-  def update_summary(self, summary: int, update: int) -> int:
-    return max(summary, update)
-
-  def __call__(self, summary: int, update: int) -> int:
-    return max(summary, update)
-
-
-# Implements a MIN rule, where the smallest integer value is always kept
-class MinIntPolicy(TuplePolicy):
-  def __init__(self):
-    TuplePolicy.__init__(self)
-
-  def create_summary(self) -> int:
-    return int(sys.maxsize)
-
-  def update_summary(self, summary: int, update: int) -> int:
-    return min(summary, update)
-
-  def __call__(self, summary: int, update: int) -> int:
-    return min(summary, update)

data/vendor/datasketches-cpp/python/datasketches/TupleWrapper.py

@@ -1,205 +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.
-
-from abc import ABC, abstractmethod
-
-from _datasketches import _tuple_sketch, _compact_tuple_sketch, _update_tuple_sketch
-from _datasketches import  _tuple_union, _tuple_intersection
-from _datasketches import _tuple_a_not_b, _tuple_jaccard_similarity
-from _datasketches import PyObjectSerDe, theta_sketch, TuplePolicy
-
-class tuple_sketch(ABC):
-  """An abstract base class representing a Tuple Sketch."""
-  _gadget: _tuple_sketch
-
-  def __str__(self, print_items:bool=False):
-    return self._gadget.to_string(print_items)
-
-  def is_empty(self):
-    """Returns True if the sketch is empty, otherwise False."""
-    return self._gadget.is_empty()
-
-  def get_estimate(self):
-    """Returns an estimate of the distinct count of the input stream."""
-    return self._gadget.get_estimate()
-
-  def get_upper_bound(self, num_std_devs:int):
-    """Returns an approximate upper bound on the estimate at standard deviations in {1, 2, 3}."""
-    return self._gadget.get_upper_bound(num_std_devs)
-
-  def get_lower_bound(self, num_std_devs:int):
-    """Returns an approximate lower bound on the estimate at standard deviations in {1, 2, 3}."""
-    return self._gadget.get_lower_bound(num_std_devs)
-
-  def is_estimation_mode(self):
-    """Returns True if the sketch is in estimation mode, otherwise False."""
-    return self._gadget.is_estimation_mode()
-
-  def get_theta(self):
-    """Returns theta (the effective sampling rate) as a fraction from 0 to 1."""
-    return self._gadget.get_theta()
-
-  def get_theta64(self):
-    """Returns theta as a 64-bit integer value."""
-    return self._gadget.get_theta64()
-
-  def get_num_retained(self):
-    """Returns the number of items currently in the sketch."""
-    return self._gadget.get_num_retained()
-
-  def get_seed_hash(self):
-    """Returns a hash of the seed used in the sketch."""
-    return self._gadget.get_seed_hash()
-
-  def is_ordered(self):
-    """Returns True if the sketch entries are sorder, otherwise False."""
-    return self._gadget.is_ordered()
-
-  def __iter__(self):
-    return self._gadget.__iter__()
-
-
-class compact_tuple_sketch(tuple_sketch):
-  """An instance of a Tuple Sketch that has been compacted and can no longer accept updates."""
-
-  def __init__(self, other:tuple_sketch, ordered:bool = True):
-    if other == None:
-      self._gadget = None
-    else:
-      self._gadget = _compact_tuple_sketch(other, ordered)
-
-  def serialize(self, serde:PyObjectSerDe):
-    """Serializes the sketch into a bytes object with the provided SerDe."""
-    return self._gadget.serialize(serde)
-
-  @classmethod
-  def from_theta_sketch(cls, sketch:theta_sketch, summary, seed:int=_tuple_sketch.DEFAULT_SEED):
-    """Creates a comapct Tuple Sketch from a Theta Sketch using a fixed summary value."""
-    self = cls.__new__(cls)
-    self._gadget = _compact_tuple_sketch(sketch, summary, seed)
-    return self
-
-  @classmethod
-  def deserialize(cls, data:bytes, serde:PyObjectSerDe, seed:int=_tuple_sketch.DEFAULT_SEED):
-    """Reads a bytes object and uses the provded SerDe to return the corresponding compact_tuple_sketch."""
-    self = cls.__new__(cls)
-    self._gadget = _compact_tuple_sketch.deserialize(data, serde, seed)
-    return self
-
-
-class update_tuple_sketch(tuple_sketch):
-  """An instance of a Tuple Sketch that is available for updates. Requires a Policy object to handle Summary values."""
-
-  def __init__(self, policy, lg_k:int = 12, p:float = 1.0, seed:int = _tuple_sketch.DEFAULT_SEED):
-    self._policy = policy
-    self._gadget = _update_tuple_sketch(self._policy, lg_k, p, seed)
-
-  def update(self, datum, value):
-    """Updates the sketch with the provided item and summary value."""
-    self._gadget.update(datum, value)
-
-  def compact(self, ordered:bool = True) -> compact_tuple_sketch:
-    """Returns a compacted form of the sketch, optionally sorting it."""
-    return self._gadget.compact(ordered)
-
-  def reset(self):
-    """Resets the sketch to the initial empty state."""
-    self._gadget.reset()
-
-
-class tuple_union:
-  """An object that can merge Tuple Sketches. Requires a Policy object to handle merging Summaries."""
-  _policy: TuplePolicy
-
-  def __init__(self, policy:TuplePolicy, lg_k:int = 12, p:float = 1.0, seed:int = _tuple_sketch.DEFAULT_SEED):
-    self._policy = policy
-    self._gadget = _tuple_union(self._policy, lg_k, p, seed)
-
-  def update(self, sketch:tuple_sketch):
-    """Updates the union with the given sketch."""
-    self._gadget.update(sketch._gadget)
-
-  def get_result(self, ordered:bool = True) -> compact_tuple_sketch:
-    """Returns the sketch corresponding to the union result, optionally sorted."""
-    return compact_tuple_sketch(self._gadget.get_result(ordered), ordered)
-
-  def reset(self):
-    """Resets the union to the initial empty state."""
-    self._gadget.reset()
-
-
-class tuple_intersection:
-  """An object that can intersect Tuple Sketches. Requires a Policy object to handle intersecting Summaries."""
-  _policy: TuplePolicy
-
-  def __init__(self, policy:TuplePolicy, seed:int = _tuple_sketch.DEFAULT_SEED):
-    self._policy = policy
-    self._gadget = _tuple_intersection(self._policy, seed)
-
-  def update(self, sketch:tuple_sketch):
-    """Intersects the provided sketch with the current intersection state."""
-    self._gadget.update(sketch._gadget)
-
-  def has_result(self) -> bool:
-    """Returns True if the intersection has a valid result, otherwise False."""
-    return self._gadget.has_result()
-
-  def get_result(self, ordered:bool = True) -> compact_tuple_sketch:
-    """Returns the sketch corresponding to the intersection result, optionally sorted."""
-    return compact_tuple_sketch(self._gadget.get_result(ordered), ordered)
-
-
-class tuple_a_not_b:
-  """An object that can peform the A-not-B operation between two sketches."""
-  def __init__(self, seed:int = _tuple_sketch.DEFAULT_SEED):
-    self._gadget = _tuple_a_not_b(seed)
-  
-  def compute(self, a:tuple_sketch, b:tuple_sketch, ordered:bool=True) -> compact_tuple_sketch:
-    """Returns a sketch with the result of applying the A-not-B operation on the given inputs."""
-    return compact_tuple_sketch(self._gadget.compute(a._gadget, b._gadget))
-
-
-class tuple_jaccard_similarity:
-  @staticmethod  
-  def jaccard(a:tuple_sketch, b:tuple_sketch, seed:int=_tuple_sketch.DEFAULT_SEED):
-    """Returns a list with {lower_bound, estimate, upper_bound} of the Jaccard similarity between sketches."""
-    return _tuple_jaccard_similarity.jaccard(a._gadget, b._gadget, seed)
-
-  @staticmethod
-  def exactly_equal(a:tuple_sketch, b:tuple_sketch, seed:int=_tuple_sketch.DEFAULT_SEED):
-    """Returns True if sketch_a and sketch_b are equivalent, otherwise False."""
-    return _tuple_jaccard_similarity.exactly_equal(a._gadget, b._gadget, seed)
-
-  @staticmethod
-  def similarity_test(actual:tuple_sketch, expected:tuple_sketch, threshold:float, seed:int=_tuple_sketch.DEFAULT_SEED):
-    """Tests similarity of an actual sketch against an expected sketch.
-
-    Computes 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.
-    """
-    return _tuple_jaccard_similarity.similarity_test(actual._gadget, expected._gadget, threshold, seed)
-
-  @staticmethod
-  def dissimilarity_test(actual:tuple_sketch, expected:tuple_sketch, threshold:float, seed:int=_tuple_sketch.DEFAULT_SEED):
-    """Tests dissimilarity of an actual sketch against an expected sketch.
-
-    Computes the upper 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.
-    """
-    return _tuple_jaccard_similarity.dissimilarity_test(actual._gadget, expected._gadget, threshold, seed)

data/vendor/datasketches-cpp/python/datasketches/__init__.py

@@ -1,38 +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.
-
-"""The Apache DataSketches Library for Python
-
-Provided under the Apache License, Verison 2.0
-<http://www.apache.org/licenses/LICENSE-2.0>
-"""
-
-name = 'datasketches'
-
-from _datasketches import *
-
-from .PySerDe import *
-from .TuplePolicy import *
-from .KernelFunction import *
-
-# Wrappers around the pybind11 classes for cases where we
-# need to define a python object that is persisted within
-# the C++ object. Currently, the native python portion of
-# a class derived from a C++ class may be garbage collected
-# even though a pointer to the C++ portion remains valid.
-from .TupleWrapper import *
-from .DensityWrapper import *

data/vendor/datasketches-cpp/python/include/kernel_function.hpp

@@ -1,98 +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 <memory>
-#include <pybind11/pybind11.h>
-#include <pybind11/numpy.h>
-
-#ifndef _KERNEL_FUNCTION_HPP_
-#define _KERNEL_FUNCTION_HPP_
-
-namespace py = pybind11;
-
-namespace datasketches {
-
-/**
- * @brief kernel_function provides the underlying base class from
- *        which native Python kernels ultimately inherit. The actual
- *        kernels implement KernelFunction, as shown in KernelFunction.py
- */
-struct kernel_function {
-  virtual double operator()(py::array_t<double>& a, const py::array_t<double>& b) const = 0;
-  virtual ~kernel_function() = default;
-};
-
-/**
- * @brief KernelFunction provides the "trampoline" class for pybind11
- *        that allows for a native Python implementation of kernel
- *        functions.
- */
-struct KernelFunction : public kernel_function {
-  using kernel_function::kernel_function;
-
-  /**
-   * @brief Evaluates K(a,b), the kernel function for the given points a and b
-   * @param a the first vector
-   * @param b the second vector
-   * @return The function value K(a,b)
-   */
-  double operator()(py::array_t<double>& a, const py::array_t<double>& b) const override {
-    PYBIND11_OVERRIDE_PURE_NAME(
-      double,          // Return type
-      kernel_function, // Parent class
-      "__call__",      // Name of function in python
-      operator(),      // Name of function in C++
-      a, b             // Arguemnts
-    );
-  }
-};
-
-/* The kernel_function_holder provides a concrete class that dispatches calls
- * from the sketch to the kernel_function. This class is needed to provide a
- * concrete object to produce a compiled library, but library users should
- * never need to use this directly.
- */
-struct kernel_function_holder {
-  explicit kernel_function_holder(std::shared_ptr<kernel_function> kernel) : _kernel(kernel) {}
-  kernel_function_holder(const kernel_function_holder& other) : _kernel(other._kernel) {}
-  kernel_function_holder(kernel_function_holder&& other) : _kernel(std::move(other._kernel)) {}
-  kernel_function_holder& operator=(const kernel_function_holder& other) { _kernel = other._kernel; return *this; }
-  kernel_function_holder& operator=(kernel_function_holder&& other) { std::swap(_kernel, other._kernel); return *this; }
-
-  double operator()(const std::vector<double>& a, const py::array_t<double>& b) const {
-    py::array_t<double> a_arr(a.size(), a.data(), dummy_array_owner);
-    return _kernel->operator()(a_arr, b);
-  }
-
-  double operator()(const std::vector<double>& a, const std::vector<double>& b) const {
-    py::array_t<double> a_arr(a.size(), a.data(), dummy_array_owner);
-    py::array_t<double> b_arr(b.size(), b.data(), dummy_array_owner);
-    return _kernel->operator()(a_arr, b_arr);
-  }
-
-  private:
-    // a dummy object to "own" arrays when translating from std::vector to avoid a copy:
-    // https://github.com/pybind/pybind11/issues/323#issuecomment-575717041
-    py::str dummy_array_owner;
-    std::shared_ptr<kernel_function> _kernel;
-};
-
-}
-
-#endif // _KERNEL_FUNCTION_HPP_

data/vendor/datasketches-cpp/python/include/py_serde.hpp

@@ -1,113 +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/functional.h>
-#include <sstream>
-
-#ifndef _PY_SERDE_HPP_
-#define _PY_SERDE_HPP_
-
-namespace py = pybind11;
-
-namespace datasketches {
-
-/**
- * @brief The py_object_serde is an abstract class that implements the
- * datasketches serde interface, and is used to allow custom Python
- * serialization of items wrapped as generic py::object types. The actual
- * Python implementation classes must extend the PyObjectSerDe class.
- */
-struct py_object_serde {
-  /**
-   * @brief Get the serialized size of an object, in bytes
-   * 
-   * @param item A provided item
-   * @return int64_t The serialized size of the item, in bytes
-   */
-  virtual int64_t get_size(const py::object& item) const = 0;
-  
-  /**
-   * @brief Serializes an item to a bytes object
-   * 
-   * @param item A provided item
-   * @return The serialized image of the item as a Python bytes object
-   */
-  virtual py::bytes to_bytes(const py::object& item) const = 0;
-  
-  /**
-   * @brief Constructs an object from a serialized image, reading the
-   * incoming buffer starting at the specified offset.
-   * 
-   * @param bytes A buffer containing items from a serialized sketch
-   * @param offset The starting offset into the bytes buffer
-   * @return A Python tuple of the reconstructed item and the total number of bytes read
-   */
-  virtual py::tuple from_bytes(py::bytes& bytes, size_t offset) const = 0;
-
-  virtual ~py_object_serde() = default;
-
-  // these methods are required by the serde interface; see common/include/serde.hpp for
-  // default implementations for C++ std::string and numeric types.
-  size_t size_of_item(const py::object& item) const;
-  size_t serialize(void* ptr, size_t capacity, const py::object* items, unsigned num) const;
-  size_t deserialize(const void* ptr, size_t capacity, py::object* items, unsigned num) const;
-};
-
-/**
- * @brief The PyObjectSerDe class provides a concrete base class
- * that pybind11 uses as a "trampoline" to pass calls through to
- * the abstract py_object_serde class. Custom Python serde implementations
- * must extend this class.
- */
-struct PyObjectSerDe : public py_object_serde {
-  using py_object_serde::py_object_serde;
-
-  // trampoline definitions -- need one for each virtual function
-  int64_t get_size(const py::object& item) const override {
-    PYBIND11_OVERRIDE_PURE(
-      int64_t,         // Return type
-      py_object_serde, // Parent class
-      get_size,        // Name of function in C++ (must match Python name)
-      item             // Argument(s)
-    );
-  }
-
-  py::bytes to_bytes(const py::object& item) const override {
-    PYBIND11_OVERRIDE_PURE(
-      py::bytes,       // Return type
-      py_object_serde, // Parent class
-      to_bytes,        // Name of function in C++ (must match Python name)
-      item             // Argument(s)
-    );
-  }
-
-  py::tuple from_bytes(py::bytes& bytes, size_t offset) const override {
-    PYBIND11_OVERRIDE_PURE(
-      py::tuple,        // Return type
-      py_object_serde,  // Parent class
-      from_bytes,       // Name of function in C++ (must match Python name)
-      bytes, offset     // Argument(s)
-    );
-  }
-};
-
-}
-
-#endif // _PY_SERDE_HPP_