datasketches 0.3.1 → 0.3.2

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

@@ -0,0 +1,87 @@
+# 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 _density_sketch, KernelFunction
+from .KernelFunction import GaussianKernel
+
+class density_sketch:
+  """An instance of a Density Sketch for kernel density estimation. Requires a KernelFunction object."""
+
+  def __init__(self, k:int, dim:int, kernel:KernelFunction=GaussianKernel()):
+    self._kernel = kernel
+    self._gadget = _density_sketch(k, dim, self._kernel)
+
+  @classmethod
+  def deserialize(cls, data:bytes, kernel:KernelFunction=GaussianKernel()):
+    """Reads a bytes object and returns a density sketch, using the provided kerenl or defaulting to a Guassian kerenl"""
+    self = cls.__new__(cls)
+    self._kernel = kernel
+    self._gadget = _density_sketch.deserialize(data, kernel)
+    return self
+
+  def update(self, point:np.array):
+    """Updates the sketch with the given point"""
+    self._gadget.update(point)
+
+  def merge(self, other:'density_sketch'):
+    """Merges the provided sketch into this one"""
+    self._gadget.merge(other._gadget)
+
+  def is_empty(self):
+    """Returns True if the sketch is empty, otherwise False"""
+    return self._gadget.is_empty()
+
+  def get_k(self):
+    """Returns the configured parameter k"""
+    return self._gadget.get_k()
+
+  def get_dim(self):
+    """Returns the configured parameter dim"""
+    return self._gadget.get_dim()
+
+  def get_n(self):
+    """Returns the length of the input stream"""
+    return self._gadget.get_n()
+
+  def get_num_retained(self):
+    """Returns the number of retained items (samples) in the sketch"""
+    return self._gadget.get_num_retained()
+
+  def is_estimation_mode(self):
+    """Returns True if the sketch is in estimation mode, otherwise False"""
+    return self._gadget.is_estimation_mode()
+
+  def get_estimate(self, point:np.array):
+    """Returns an approximate density at the given point"""
+    return self._gadget.get_estimate(point)
+
+  def serialize(self):
+    """Serializes the sketch into a bytes object"""
+    return self._gadget.serialize()
+
+  def __str__(self, print_levels:bool=False, print_items:bool=False):
+    """Produces a string summary of the sketch"""
+    return self._gadget.to_string(print_levels, print_items)
+
+  def to_string(self, print_levels:bool=False, print_items:bool=False):
+    """Produces a string summary of the sketch"""
+    return self._gadget.to_string(print_levels, print_items)
+
+  def __iter__(self):
+    return self._gadget.__iter__()

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

@@ -0,0 +1,35 @@
+# 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

@@ -54,51 +54,57 @@ class PyStringsSerDe(PyObjectSerDe):
     str = data[offset+4:offset+4+num_chars].decode()
     return (str, 4+num_chars)
 
-# Implements an integer-encoding scheme where each integer is written
+# 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)
+    return struct.pack('<i', item)
 
   def from_bytes(self, data: bytes, offset: int):
-    val = struct.unpack_from('i', data, offset)[0]
+    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)
+    return struct.pack('<l', item)
 
   def from_bytes(self, data: bytes, offset: int):
-    val = struct.unpack_from('l', data, offset)[0]
+    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)
+    return struct.pack('<f', item)
 
   def from_bytes(self, data: bytes, offset: int):
-    val = struct.unpack_from('f', data, offset)[0]
+    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)
+    return struct.pack('<d', item)
 
   def from_bytes(self, data: bytes, offset: int):
-    val = struct.unpack_from('d', data, offset)[0]
+    val = struct.unpack_from('<d', data, offset)[0]
     return (val, 8)

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

@@ -0,0 +1,77 @@
+# 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

@@ -0,0 +1,205 @@
+# 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

@@ -15,8 +15,24 @@
 # 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 *
 
-from _datasketches 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

@@ -0,0 +1,98 @@
+/*
+ * 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_object_lt.hpp

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+#ifndef _PY_OBJECT_LT_HPP_
+#define _PY_OBJECT_LT_HPP_
+
+#include <pybind11/pybind11.h>
+
+/*
+  This header defines a less than operator on generic python
+  objects. The implementation calls the object's built-in __lt__()
+  method. If that method is not defined, the call may fail.
+*/
+
+struct py_object_lt {
+  bool operator()(const pybind11::object& a, const pybind11::object& b) const {
+    return a < b;
+  }
+};
+
+#endif // _PY_OBJECT_LT_HPP_

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

@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+
+#ifndef _PY_OBJECT_OSTREAM_HPP_
+#define _PY_OBJECT_OSTREAM_HPP_
+
+#include <pybind11/pybind11.h>
+
+#include <string>
+#include <ostream>
+
+/*
+  This header defines an ostream output operator on a generic python
+  object. The implementation calls the object's built-in __str__()
+  method. If that method is not defined, the call may fail.
+
+  NOTE: This header must be included before the inclusion of
+        any sketch classes.
+*/
+
+namespace py = pybind11;
+
+namespace datasketches {
+
+static std::ostream& operator<<(std::ostream& os, const py::object& obj) {
+  os << std::string(pybind11::str(obj));
+  return os;
+}
+
+}
+
+#endif // _PY_OBJECT_OSTREAM_HPP_