datasketches 0.2.7 → 0.3.0

data/vendor/datasketches-cpp/kll/test/kll_sketch_validation.cpp

@@ -22,14 +22,11 @@
 #include <kll_sketch.hpp>
 #include <kll_helper.hpp>
 
-#include <assert.h>
-
 #ifdef KLL_VALIDATION
 
 // This is to make sure the implementation matches exactly the reference implementation in OCaml.
-// Conditional compilation is used because the implementation needs a few modifications:
-// - switch from random choice to deterministic
-// - a few methods to expose internals of the sketch
+// Conditional compilation is used because the implementation needs
+// to switch from random choice to deterministic
 
 namespace datasketches {
 
@@ -154,11 +151,11 @@ const int64_t correct_results[num_tests * 7] = {
     113, 200, 8311133, 6554171, 16, 637, 121111429906734123
 };
 
-static std::unique_ptr<int[]> make_input_array(unsigned n, unsigned stride) {
-  assert (kll_helper::is_odd(stride));
-  unsigned mask((1 << 23) - 1); // because library items are single-precision floats at the moment
-  unsigned cur(0);
-  std::unique_ptr<int[]> arr(new int[n]);
+static std::vector<int> make_input_array(unsigned n, unsigned stride) {
+  if (!kll_helper::is_odd(stride)) throw std::logic_error("stride must be odd");
+  unsigned mask = (1 << 23) - 1; // because items are single-precision floats at the moment
+  unsigned cur = 0;
+  std::vector<int> arr(n, 0);
   for (unsigned i = 0; i < n; i++) {
     cur += stride;
     cur &= mask;
@@ -167,50 +164,63 @@ static std::unique_ptr<int[]> make_input_array(unsigned n, unsigned stride) {
   return arr;
 }
 
-static int64_t simple_hash_of_sub_array(const float* arr, unsigned start, unsigned length) {
-  int64_t multiplier(738219921); // an arbitrary odd 30-bit number
-  int64_t mask60((1ULL << 60) - 1ULL);
-  int64_t accum(0);
-  for (unsigned i = start; i < start + length; i++) {
-    accum += (int64_t) arr[i];
+template<typename It>
+std::pair<int64_t, uint8_t> hash_samples_and_count_levels(It from, It to) {
+  int64_t multiplier = 738219921; // an arbitrary odd 30-bit number
+  int64_t mask60 = (1ULL << 60) - 1ULL;
+  int64_t accum = 0;
+  uint8_t num_levels = 1;
+  for (auto it = from; it != to; ++it) {
+    accum += static_cast<int64_t>((*it).first);
     accum *= multiplier;
     accum &= mask60;
     accum ^= accum >> 30;
+    const uint8_t level = count_trailing_zeros_in_u64((*it).second);
+    if (num_levels <= level) num_levels = level + 1;
   }
-  return accum;
+  return std::pair<uint64_t, uint8_t>(accum, num_levels);
 }
 
 TEST_CASE("kll validation", "[kll_sketch][validation]") {
   for (unsigned i = 0; i < num_tests; i++) {
-    assert (correct_results[7 * i] == i);
-    unsigned k(correct_results[7 * i + 1]);
-    unsigned n(correct_results[7 * i + 2]);
-    unsigned stride(correct_results[7 * i + 3]);
-    std::unique_ptr<int[]> input_array = make_input_array(n, stride);
+    if (correct_results[7 * i] != i) throw std::logic_error("test number mismatch");
+    unsigned k = correct_results[7 * i + 1];
+    unsigned n = correct_results[7 * i + 2];
+    unsigned stride = correct_results[7 * i + 3];
+    auto input_array = make_input_array(n, stride);
     kll_sketch<float> sketch(k);
     kll_next_offset = 0;
     for (unsigned j = 0; j < n; j++) {
       sketch.update(input_array[j]);
     }
-    unsigned num_levels = sketch.get_num_levels();
     unsigned num_samples = sketch.get_num_retained();
-    int64_t hashed_samples = simple_hash_of_sub_array(sketch.get_items(), sketch.get_levels()[0], num_samples);
+    auto p = hash_samples_and_count_levels(sketch.begin(), sketch.end());
     std::cout << i;
-    REQUIRE(correct_results[7 * i + 4] == num_levels);
+    REQUIRE(correct_results[7 * i + 4] == p.second);
     REQUIRE(correct_results[7 * i + 5] == num_samples);
-    if (correct_results[7 * i + 6] == hashed_samples) {
+    if (correct_results[7 * i + 6] == p.first) {
       std::cout << " pass" << std::endl;
     } else {
-      std::cout << " " << (correct_results[7 * i + 6]) << " != " << hashed_samples;
-      sketch.to_stream(std::cout);
+      std::cout << " " << (correct_results[7 * i + 6]) << " != " << p.first << "\n";
+      std::cout << sketch.to_string();
       FAIL();
     }
   }
 }
 
-TEST_CASE("kll validation: test hash", "[kll_sketch][validaiton]") {
-  float array[] = { 907500, 944104, 807020, 219921, 678370, 955217, 426885 };
-  REQUIRE(simple_hash_of_sub_array(array, 1, 5) == 1141543353991880193LL);
+TEST_CASE("kll validation: test hash and num levels", "[kll_sketch][validaiton]") {
+  std::pair<float, uint64_t> array[] = {
+    std::make_pair(907500, 1),
+    std::make_pair(944104, 1),
+    std::make_pair(807020, 2),
+    std::make_pair(219921, 2),
+    std::make_pair(678370, 2),
+    std::make_pair(955217, 4),
+    std::make_pair(426885, 8)
+  };
+  auto hash_and_num_levels = hash_samples_and_count_levels(array + 1, array + 6);
+  REQUIRE(hash_and_num_levels.first == 1141543353991880193LL);
+  REQUIRE(hash_and_num_levels.second == 3);
 }
 
 TEST_CASE("kll validation: make input array", "[kll_sketch][validaiton]") {

data/vendor/datasketches-cpp/pyproject.toml

@@ -1,18 +1,23 @@
+# 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.
+
 [build-system]
 requires = ["wheel",
             "setuptools >= 30.3.0",
             "cmake >= 3.16",
             "pybind11[global] >= 2.6.0"]
 build-backend = "setuptools.build_meta"
-
-[tool.tox]
-legacy_tox_ini = """
-[tox]
-envlist = py3
-
-[testenv]
-deps = pytest
-       numpy
-changedir = python/tests
-commands = pytest
-"""

data/vendor/datasketches-cpp/python/CMakeLists.txt

@@ -50,7 +50,13 @@ target_link_libraries(python
 
 set_target_properties(python PROPERTIES
   PREFIX ""
-  OUTPUT_NAME datasketches
+  OUTPUT_NAME _datasketches
+)
+
+target_include_directories(python
+  PUBLIC
+    $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 )
 
 # ensure we make a .so on Mac rather than .dylib
@@ -71,4 +77,5 @@ target_sources(python
     src/quantiles_wrapper.cpp
     src/ks_wrapper.cpp
     src/vector_of_kll.cpp
+    src/py_serde.cpp
 )

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

@@ -0,0 +1,104 @@
+# 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)
+
+
+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)
+
+
+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)
+
+
+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/__init__.py

@@ -0,0 +1,22 @@
+# 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'
+
+from .PySerDe import *
+
+from _datasketches import *

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

@@ -0,0 +1,113 @@
+/*
+ * 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_

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

@@ -40,20 +40,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "### Update Theta sketch summary:\n",
-      "   lg nominal size      : 12\n",
-      "   lg current size      : 13\n",
-      "   num retained keys    : 6560\n",
-      "   resize factor        : 8\n",
-      "   sampling probability : 1\n",
+      "### 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",
-      "   estimation mode?     : true\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"
      ]
@@ -100,7 +100,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can serialize and reconstruct the sketch. If we compact the sketch prior to serialization, we can still query the rebuilt sketch but cannot update it further."
+    "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."
    ]
   },
   {
@@ -139,7 +139,7 @@
     }
    ],
    "source": [
-    "new_sk1 = theta_sketch.deserialize(sk1_bytes)\n",
+    "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())"
    ]
@@ -169,20 +169,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "### Update Theta sketch summary:\n",
-      "   lg nominal size      : 13\n",
-      "   lg current size      : 14\n",
-      "   num retained keys    : 12488\n",
-      "   resize factor        : 8\n",
-      "   sampling probability : 1\n",
+      "### 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",
-      "   estimation mode?     : true\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"
      ]
@@ -255,13 +255,14 @@
      "output_type": "stream",
      "text": [
       "Has result:  True\n",
-      "### Compact Theta sketch summary:\n",
-      "   num retained keys    : 1668\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",
-      "   estimation mode?     : true\n",
       "   estimate             : 254959\n",
       "   lower bound 95% conf : 242739\n",
       "   upper bound 95% conf : 267789\n",
@@ -326,13 +327,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "### Compact Theta sketch summary:\n",
-      "   num retained keys    : 4892\n",
+      "### 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",
-      "   estimation mode?     : true\n",
       "   estimate             : 747756\n",
       "   lower bound 95% conf : 726670\n",
       "   upper bound 95% conf : 769452\n",
@@ -374,7 +376,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3.10.6 64-bit",
    "language": "python",
    "name": "python3"
   },
@@ -388,7 +390,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.0"
+   "version": "3.10.6"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
+   }
   }
  },
  "nbformat": 4,

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

@@ -1,3 +1,21 @@
+:: 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,2 +1,18 @@
+# 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/datasketches.cpp

@@ -21,6 +21,7 @@
 
 namespace py = pybind11;
 
+// sketches
 void init_hll(py::module& m);
 void init_kll(py::module& m);
 void init_fi(py::module& m);
@@ -29,10 +30,13 @@ void init_theta(py::module& m);
 void init_vo(py::module& m);
 void init_req(py::module& m);
 void init_quantiles(py::module& m);
-void init_kolmogorov_smirnov(py::module& m);
 void init_vector_of_kll(py::module& m);
 
-PYBIND11_MODULE(datasketches, 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);
@@ -41,6 +45,8 @@ PYBIND11_MODULE(datasketches, m) {
   init_vo(m);
   init_req(m);
   init_quantiles(m);
-  init_kolmogorov_smirnov(m);
   init_vector_of_kll(m);
+
+  init_kolmogorov_smirnov(m);
+  init_serde(m);
 }