Function PYBIND11_MODULE

src/wrapper.cpp:18–1182

PYBIND11_MAKE_OPAQUE(std::vector<std::int64_t>);

PYBIND11_MODULE(seal, m)
{
    m.doc() = "Microsoft SEAL for Python, from https://github.com/Huelse/SEAL-Python";
    m.attr("__version__")  = "4.1.2.1";

    py::bind_vector<std::vector<double>>(
        m, "VectorDouble", py::buffer_protocol(),
        SEAL_DOC("Vector container for double values used by SEAL encoders."));
    py::bind_vector<std::vector<std::complex<double>>>(
        m, "VectorComplex", py::buffer_protocol(),
        SEAL_DOC("Vector container for complex<double> values used by CKKS."));
    py::bind_vector<std::vector<std::uint64_t>>(
        m, "VectorUInt", py::buffer_protocol(),
        SEAL_DOC("Vector container for unsigned 64-bit integer slots."));
    py::bind_vector<std::vector<std::int64_t>>(
        m, "VectorInt", py::buffer_protocol(),
        SEAL_DOC("Vector container for signed 64-bit integer slots."));

    // encryptionparams.h
    py::enum_<scheme_type>(m, "scheme_type", SEAL_DOC("Describes the homomorphic encryption scheme to use."))
        .value("none", scheme_type::none)
        .value("bfv", scheme_type::bfv)
        .value("ckks", scheme_type::ckks)
        .value("bgv", scheme_type::bgv);

    // serialization.h
    py::enum_<compr_mode_type>(m, "compr_mode_type", SEAL_DOC("Compression mode used when serializing SEAL objects."))
        .value("none", compr_mode_type::none)
#ifdef SEAL_USE_ZLIB
        .value("zlib", compr_mode_type::zlib)
#endif
#ifdef SEAL_USE_ZSTD
        .value("zstd", compr_mode_type::zstd)
#endif
        ;

    // memorymanager.h
    py::class_<MemoryPoolHandle>(
        m, "MemoryPoolHandle",
        SEAL_DOC("Handle to a memory pool used by SEAL for efficient temporary allocations."))
        .def(py::init<>(), SEAL_DOC("Construct an uninitialized memory pool handle."))
        .def_static("Global", &MemoryPoolHandle::Global, SEAL_DOC("Return a handle to the global memory pool."))
#ifndef _M_CEE
        .def_static("ThreadLocal", &MemoryPoolHandle::ThreadLocal, SEAL_DOC("Return a handle to the thread-local memory pool."))
#endif
        .def_static(
            "New", &MemoryPoolHandle::New, py::arg("clear_on_destruction") = false,
            SEAL_DOC("Create a new independent memory pool."))
        .def("pool_count", &MemoryPoolHandle::pool_count, SEAL_DOC("Return the number of memory pools referenced by this handle."))
        .def("alloc_byte_count", &MemoryPoolHandle::alloc_byte_count, SEAL_DOC("Return the number of bytes allocated by the pool."))
        .def("use_count", &MemoryPoolHandle::use_count, SEAL_DOC("Return the reference count of the underlying pool."))
        .def("is_initialized", [](const MemoryPoolHandle &pool){
            return static_cast<bool>(pool);
        }, SEAL_DOC("Return True if this handle points to an initialized memory pool."));

    py::class_<MemoryManager>(m, "MemoryManager", SEAL_DOC("Factory for retrieving SEAL memory pools."))
        .def_static("GetPool", [](){
            return MemoryManager::GetPool();