datasketches 0.3.2 → 0.4.1

data/vendor/datasketches-cpp/python/jupyter/ThetaSketchNotebook.ipynb

@@ -1,403 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Theta Sketch Examples"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Basic Sketch Usage"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from datasketches import theta_sketch, update_theta_sketch, compact_theta_sketch\n",
-    "from datasketches import theta_union, theta_intersection, theta_a_not_b"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To start, we'll create a sketch with 1 million points in order to demonstrate basic sketch operations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "### Theta sketch summary:\n",
-      "   num retained entries : 6560\n",
-      "   seed hash            : 37836\n",
-      "   empty?               : false\n",
-      "   ordered?             : false\n",
-      "   estimation mode?     : true\n",
-      "   theta (fraction)     : 0.00654224\n",
-      "   theta (raw 64-bit)   : 60341508738660257\n",
-      "   estimate             : 1.00271e+06\n",
-      "   lower bound 95% conf : 978261\n",
-      "   upper bound 95% conf : 1.02778e+06\n",
-      "   lg nominal size      : 12\n",
-      "   lg current size      : 13\n",
-      "   resize factor        : 8\n",
-      "### End sketch summary\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "n = 1000000\n",
-    "k = 12\n",
-    "sk1 = update_theta_sketch(k)\n",
-    "for i in range(0, n):\n",
-    "    sk1.update(i)\n",
-    "print(sk1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The summary contains most data fo interest, but we can also query for specific information. And in this case, since we know the exact number of distinct items presented ot the sketch, we can look at the estimate, upper, and lower bounds as a percentage of the exact value."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Upper bound (1 std. dev) as % of true value:\t 101.5208\n",
-      "Sketch estimate as % of true value:\t\t 100.2715\n",
-      "Lower bound (1 std. dev) as % of true value:\t 99.0374\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Upper bound (1 std. dev) as % of true value:\\t\", round(100*sk1.get_upper_bound(1) / n, 4))\n",
-    "print(\"Sketch estimate as % of true value:\\t\\t\", round(100*sk1.get_estimate() / n, 4))\n",
-    "print(\"Lower bound (1 std. dev) as % of true value:\\t\", round(100*sk1.get_lower_bound(1) / n, 4))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can serialize and reconstruct the sketch. Serialization necessarily produces a compact sketch, meaning the sketch can be deserialized and queried or used for further unions or set operations but can not be updated directly."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "52504"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "sk1_bytes = sk1.compact().serialize()\n",
-    "len(sk1_bytes)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Estimate: \t\t 1002714.745231455\n",
-      "Estimation mode: \t True\n"
-     ]
-    }
-   ],
-   "source": [
-    "new_sk1 = compact_theta_sketch.deserialize(sk1_bytes)\n",
-    "print(\"Estimate: \\t\\t\", new_sk1.get_estimate())\n",
-    "print(\"Estimation mode: \\t\", new_sk1.is_estimation_mode())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Sketch Unions"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Theta Sketch unions make use of a separate union object. The union will accept input sketches with different values of $k$.\n",
-    "\n",
-    "For this example, we will create a sketch with distinct values that partially overlap those in `sk1`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "### Theta sketch summary:\n",
-      "   num retained entries : 12488\n",
-      "   seed hash            : 37836\n",
-      "   empty?               : false\n",
-      "   ordered?             : false\n",
-      "   estimation mode?     : true\n",
-      "   theta (fraction)     : 0.0123336\n",
-      "   theta (raw 64-bit)   : 113757656857900725\n",
-      "   estimate             : 1.01252e+06\n",
-      "   lower bound 95% conf : 994626\n",
-      "   upper bound 95% conf : 1.03073e+06\n",
-      "   lg nominal size      : 13\n",
-      "   lg current size      : 14\n",
-      "   resize factor        : 8\n",
-      "### End sketch summary\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "offset = int(3 * n / 4)\n",
-    "sk2 = update_theta_sketch(k+1)\n",
-    "for i in range(0, n):\n",
-    "    sk2.update(i + offset)\n",
-    "print(sk2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can now feed the sketches into the union. As constructed, the exact number of unique values presented to the two sketches is $\\frac{7}{4}n$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Union estimate as % of true value:  99.6787\n"
-     ]
-    }
-   ],
-   "source": [
-    "union = theta_union(k)\n",
-    "union.update(sk1)\n",
-    "union.update(sk2)\n",
-    "result = union.get_result()\n",
-    "print(\"Union estimate as % of true value: \", round(100*result.get_estimate()/(1.75*n), 4))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Sketch Intersections"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Beyond unions, theta sketches also support intersctions through the use of an intersection object. These set intersections can have vastly superior error bounds than the classic inclusion-exclusion rule used with sketches like HLL."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Has result:  True\n",
-      "### Theta sketch summary:\n",
-      "   num retained entries : 1668\n",
-      "   seed hash            : 37836\n",
-      "   empty?               : false\n",
-      "   ordered?             : true\n",
-      "   estimation mode?     : true\n",
-      "   theta (fraction)     : 0.00654224\n",
-      "   theta (raw 64-bit)   : 60341508738660257\n",
-      "   estimate             : 254959\n",
-      "   lower bound 95% conf : 242739\n",
-      "   upper bound 95% conf : 267789\n",
-      "### End sketch summary\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "intersection = theta_intersection()\n",
-    "intersection.update(sk1)\n",
-    "intersection.update(sk2)\n",
-    "print(\"Has result: \", intersection.has_result())\n",
-    "result = intersection.get_result()\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this case, we expect the sets to have an overlap of $\\frac{1}{4}n$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Intersection estimate as % of true value:  101.9834\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Intersection estimate as % of true value: \", round(100*result.get_estimate()/(0.25*n), 4))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Set Subtraction (A-not-B)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally, we have the set subtraction operation. Unlike `theta_union` and `theta_intersection`, `theta_a_not_b` always takes as input 2 sketches at a time, namely $a$ and $b$, and directly returns the result as a sketch."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "### Theta sketch summary:\n",
-      "   num retained entries : 4892\n",
-      "   seed hash            : 37836\n",
-      "   empty?               : false\n",
-      "   ordered?             : true\n",
-      "   estimation mode?     : true\n",
-      "   theta (fraction)     : 0.00654224\n",
-      "   theta (raw 64-bit)   : 60341508738660257\n",
-      "   estimate             : 747756\n",
-      "   lower bound 95% conf : 726670\n",
-      "   upper bound 95% conf : 769452\n",
-      "### End sketch summary\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "anb = theta_a_not_b()\n",
-    "result = anb.compute(sk1, sk2)\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "By using the same two sketches as before, the expected result here is $\\frac{3}{4}n$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "A-not-B estimate as % of true value:  99.7008\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"A-not-B estimate as % of true value: \", round(100*result.get_estimate()/(0.75*n), 4))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3.10.6 64-bit",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.6"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

data/vendor/datasketches-cpp/python/pybind11Path.cmd

@@ -1,21 +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.
-
-
-@echo off
-:: Takes path to the Python interpreter and returns the path to pybind11
-%1 -c "import pybind11,sys;sys.stdout.write(pybind11.get_cmake_dir())"

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

@@ -1,18 +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.
-
-name = "datasketches"

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

@@ -1,101 +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 "count_min.hpp"
-#include "common_defs.hpp"
-
-namespace py = pybind11;
-
-template<typename W>
-void bind_count_min_sketch(py::module &m, const char* name) {
-  using namespace datasketches;
-
-  py::class_<count_min_sketch<W>>(m, name)
-    .def(py::init<uint8_t, uint32_t, uint64_t>(), py::arg("num_hashes"), py::arg("num_buckets"), py::arg("seed")=DEFAULT_SEED)
-    .def(py::init<const count_min_sketch<W>&>())
-    .def_static("suggest_num_buckets", &count_min_sketch<W>::suggest_num_buckets, py::arg("relative_error"),
-                "Suggests the number of buckets needed to achieve an accuracy within the provided "
-                "relative_error. For example, when relative_error = 0.05, the returned frequency estimates "
-                "satisfy the 'relative_error' guarantee that never overestimates the weights but may "
-                "underestimate the weights by 5% of the total weight in the sketch. "
-                "Returns the number of hash buckets at every level of the sketch required in order to obtain "
-                "the specified relative error.")
-    .def_static("suggest_num_hashes", &count_min_sketch<W>::suggest_num_hashes, py::arg("confidence"),
-                "Suggests the number of hashes needed to achieve the provided confidence. For example, "
-                "with 95% confidence, frequency estimates satisfy the 'relative_error' guarantee. "
-                "Returns the number of hash functions that are required in order to achieve the specified "
-                "confidence of the sketch. confidence = 1 - delta, with delta denoting the sketch failure probability.")
-    .def("__str__", &count_min_sketch<W>::to_string,
-         "Produces a string summary of the sketch")
-    .def("to_string", &count_min_sketch<W>::to_string,
-         "Produces a string summary of the sketch")
-    .def("is_empty", &count_min_sketch<W>::is_empty,
-         "Returns True if the sketch has seen no items, otherwise False")
-    .def("get_num_hashes", &count_min_sketch<W>::get_num_hashes,
-         "Returns the configured number of hashes for the sketch")
-    .def("get_num_buckets", &count_min_sketch<W>::get_num_buckets,
-         "Returns the configured number of buckets for the sketch")
-    .def("get_seed", &count_min_sketch<W>::get_seed,
-         "Returns the base hash seed for the sketch")
-    .def("get_relative_error", &count_min_sketch<W>::get_relative_error,
-         "Returns the maximum permissible error for any frequency estimate query")
-    .def("get_total_weight", &count_min_sketch<W>::get_total_weight,
-         "Returns the total weight currently inserted into the stream")
-    .def("update", static_cast<void (count_min_sketch<W>::*)(int64_t, W)>(&count_min_sketch<W>::update), py::arg("item"), py::arg("weight")=1.0,
-         "Updates the sketch with the given 64-bit integer value")
-    .def("update", static_cast<void (count_min_sketch<W>::*)(const std::string&, W)>(&count_min_sketch<W>::update), py::arg("item"), py::arg("weight")=1.0,
-         "Updates the sketch with the given string")
-    .def("get_estimate", static_cast<W (count_min_sketch<W>::*)(int64_t) const>(&count_min_sketch<W>::get_estimate), py::arg("item"),
-         "Returns an estimate of the frequency of the provided 64-bit integer value")
-    .def("get_estimate", static_cast<W (count_min_sketch<W>::*)(const std::string&) const>(&count_min_sketch<W>::get_estimate), py::arg("item"),
-         "Returns an estimate of the frequency of the provided string")
-    .def("get_upper_bound", static_cast<W (count_min_sketch<W>::*)(int64_t) const>(&count_min_sketch<W>::get_upper_bound), py::arg("item"),
-         "Returns an upper bound on the estimate for the given 64-bit integer value")
-    .def("get_upper_bound", static_cast<W (count_min_sketch<W>::*)(const std::string&) const>(&count_min_sketch<W>::get_upper_bound), py::arg("item"),
-         "Returns an upper bound on the estimate for the provided string")
-    .def("get_lower_bound", static_cast<W (count_min_sketch<W>::*)(int64_t) const>(&count_min_sketch<W>::get_lower_bound), py::arg("item"),
-         "Returns an lower bound on the estimate for the given 64-bit integer value")
-    .def("get_lower_bound", static_cast<W (count_min_sketch<W>::*)(const std::string&) const>(&count_min_sketch<W>::get_lower_bound), py::arg("item"),
-         "Returns an lower bound on the estimate for the provided string")
-    .def("merge", &count_min_sketch<W>::merge, py::arg("other"),
-         "Merges the provided other sketch into this one")
-    .def("get_serialized_size_bytes", &count_min_sketch<W>::get_serialized_size_bytes,
-         "Returns the size in bytes of the serialized image of the sketch")
-    .def(
-        "serialize",
-        [](const count_min_sketch<W>& 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) { return count_min_sketch<W>::deserialize(bytes.data(), bytes.size()); },
-        py::arg("bytes"),
-        "Reads a bytes object and returns the corresponding count_min_sketch"
-    );
-}
-
-void init_count_min(py::module &m) {
-  bind_count_min_sketch<double>(m, "count_min_sketch");
-}
-

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

@@ -1,76 +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 "cpc_sketch.hpp"
-#include "cpc_union.hpp"
-#include "cpc_common.hpp"
-#include "common_defs.hpp"
-
-namespace py = pybind11;
-
-void init_cpc(py::module &m) {
-  using namespace datasketches;
-
-  py::class_<cpc_sketch>(m, "cpc_sketch")
-    .def(py::init<uint8_t, uint64_t>(), py::arg("lg_k")=cpc_constants::DEFAULT_LG_K, py::arg("seed")=DEFAULT_SEED)
-    .def(py::init<const cpc_sketch&>())
-    .def("__str__", &cpc_sketch::to_string,
-         "Produces a string summary of the sketch")
-    .def("to_string", &cpc_sketch::to_string,
-         "Produces a string summary of the sketch")
-    .def<void (cpc_sketch::*)(uint64_t)>("update", &cpc_sketch::update, py::arg("datum"),
-         "Updates the sketch with the given 64-bit integer value")
-    .def<void (cpc_sketch::*)(double)>("update", &cpc_sketch::update, py::arg("datum"),
-         "Updates the sketch with the given 64-bit floating point")
-    .def<void (cpc_sketch::*)(const std::string&)>("update", &cpc_sketch::update, py::arg("datum"),
-         "Updates the sketch with the given string")
-    .def("is_empty", &cpc_sketch::is_empty,
-         "Returns True if the sketch is empty, otherwise False")
-    .def("get_estimate", &cpc_sketch::get_estimate,
-         "Estimate of the distinct count of the input stream")
-    .def("get_lower_bound", &cpc_sketch::get_lower_bound, py::arg("kappa"),
-         "Returns an approximate lower bound on the estimate for kappa values in {1, 2, 3}, roughly corresponding to standard deviations")
-    .def("get_upper_bound", &cpc_sketch::get_upper_bound, py::arg("kappa"),
-         "Returns an approximate upper bound on the estimate for kappa values in {1, 2, 3}, roughly corresponding to standard deviations")
-    .def(
-        "serialize",
-        [](const cpc_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) { return cpc_sketch::deserialize(bytes.data(), bytes.size()); },
-        py::arg("bytes"),
-        "Reads a bytes object and returns the corresponding cpc_sketch"
-    );
-
-  py::class_<cpc_union>(m, "cpc_union")
-    .def(py::init<uint8_t, uint64_t>(), py::arg("lg_k"), py::arg("seed")=DEFAULT_SEED)
-    .def(py::init<const cpc_union&>())
-    .def("update", (void (cpc_union::*)(const cpc_sketch&)) &cpc_union::update, py::arg("sketch"),
-         "Updates the union with the provided CPC sketch")
-    .def("get_result", &cpc_union::get_result,
-         "Returns a CPC sketch with the result of the union")
-    ;
-}

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

@@ -1,58 +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>
-
-namespace py = pybind11;
-
-// sketches
-void init_hll(py::module& m);
-void init_kll(py::module& m);
-void init_fi(py::module& m);
-void init_cpc(py::module& m);
-void init_theta(py::module& m);
-void init_tuple(py::module& m);
-void init_vo(py::module& m);
-void init_req(py::module& m);
-void init_quantiles(py::module& m);
-void init_count_min(py::module& m);
-void init_density(py::module& m);
-void init_vector_of_kll(py::module& m);
-
-// supporting objects
-void init_kolmogorov_smirnov(py::module& m);
-void init_serde(py::module& m);
-
-PYBIND11_MODULE(_datasketches, m) {
-  init_hll(m);
-  init_kll(m);
-  init_fi(m);
-  init_cpc(m);
-  init_theta(m);
-  init_tuple(m);
-  init_vo(m);
-  init_req(m);
-  init_quantiles(m);
-  init_count_min(m);
-  init_density(m);
-  init_vector_of_kll(m);
-
-  init_kolmogorov_smirnov(m);
-  init_serde(m);
-}