quasardb 3.14.2.dev1__cp312-cp312-macosx_11_0_arm64.whl → 3.14.2.dev4__cp312-cp312-macosx_11_0_arm64.whl

quasardb/dispatch.hpp

@@ -1,157 +0,0 @@
-#pragma once
-
-#include "concepts.hpp"
-#include "error.hpp"
-#include "numpy.hpp"
-#include "traits.hpp"
-#include <string>
-
-/**
- * Define various way to do runtime -> compile time template dispatch for the
- * types that we have.
- */
-namespace qdb::dispatch
-{
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// DTYPE DISPATCHER
-//
-// Most complex dispatcher: dispatch based on dtype size, kind, and could even
-// be extended to datetime precision and whatnot.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-template <template <qdb_ts_column_type_t, typename> class Callback,
-    qdb_ts_column_type_t ColumnType,
-    typename DType,
-    typename... Args>
-concept valid_callback = requires(Args... args) {
-                             {
-                                 Callback<ColumnType, DType>{}
-                             };
-                             {
-                                 Callback<ColumnType, DType>{}(std::forward<Args>(args)...)
-                             };
-                         };
-
-template <template <qdb_ts_column_type_t, typename> class Callback,
-    qdb_ts_column_type_t ColumnType,
-    concepts::dtype DType,
-    typename... Args>
-    requires(not valid_callback<Callback, ColumnType, DType, Args...>)
-static inline constexpr void by_dtype_(Args &&... args)
-{
-    throw qdb::incompatible_type_exception{"Dtype dispatcher not implemented for ColumnType '"
-                                           + std::to_string(ColumnType)
-                                           + "': " + numpy::detail::to_string(DType::dtype())};
-};
-
-// Template is only expanded when it actually has a dispatch function with the
-// correct signature.
-template <template <qdb_ts_column_type_t, typename> class Callback,
-    qdb_ts_column_type_t ColumnType,
-    concepts::dtype DType,
-    typename... Args>
-
-    requires(valid_callback<Callback, ColumnType, DType, Args...>)
-static inline constexpr decltype(auto) by_dtype_(Args &&... args)
-{
-    return Callback<ColumnType, DType>{}(std::forward<Args>(args)...);
-};
-
-/**
- * Converts runtime kind/size into compile-time template function dispatch.
- *
- * TODO(leon): possibly allow choice whgether or not to raise a compile-time error
- *             on unimplemented template functions, right now it assumes these are
- *             just side effects on template expansion overload: the fact that a
- *             C++ compiler decides to generate functions for all possible
- *             combinations of dtype properties.
- */
-template <template <qdb_ts_column_type_t, typename> class Callback,
-    qdb_ts_column_type_t ColumnType,
-    typename... Args>
-static inline constexpr decltype(auto) by_dtype(
-    traits::dtype_kind kind, py::ssize_t size, Args &&... args)
-{
-#define CASE(K, DT) \
-    case K:         \
-        return by_dtype_<Callback, ColumnType, DT, Args...>(std::forward<Args>(args)...);
-
-    switch (kind)
-    {
-        CASE(traits::unicode_kind, traits::unicode_dtype);
-        CASE(traits::bytestring_kind, traits::bytestring_dtype);
-        CASE(traits::datetime_kind, traits::datetime64_ns_dtype);
-        CASE(traits::object_kind, traits::pyobject_dtype);
-
-    case traits::int_kind:
-        switch (size)
-        {
-            CASE(2, traits::int16_dtype);
-            CASE(4, traits::int32_dtype);
-            CASE(8, traits::int64_dtype);
-        default:
-            throw qdb::not_implemented_exception{
-                "Integer dtype with size " + std::to_string(size) + " is not supported"};
-        };
-
-    case traits::float_kind:
-        switch (size)
-        {
-            CASE(4, traits::float32_dtype);
-            CASE(8, traits::float64_dtype);
-        default:
-            throw qdb::not_implemented_exception{
-                "Integer dtype with size " + std::to_string(size) + " is not supported"};
-        };
-
-    default:
-        throw qdb::not_implemented_exception{
-            "Unable to dispatch: dtype with kind '" + std::string{(char)kind, 1} + "' not recognized"};
-    };
-
-#undef SIZED_CASE3
-#undef SIZED_CASE2
-#undef CASE
-}
-
-template <template <qdb_ts_column_type_t, typename> class Callback,
-    qdb_ts_column_type_t ColumnType,
-    typename... Args>
-static inline constexpr decltype(auto) by_dtype(py::dtype const & dt, Args &&... args)
-{
-    return by_dtype<Callback, ColumnType, Args...>(
-        static_cast<traits::dtype_kind>(dt.kind()), dt.itemsize(), std::forward<Args>(args)...);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// COLUMN TYPE DISPATCHER
-//
-////////////////////////////////////////////////////////////////////////////////
-
-template <template <qdb_ts_column_type_t> class Callback, typename... Args>
-static inline constexpr decltype(auto) by_column_type(qdb_ts_column_type_t ct, Args &&... args)
-{
-    switch (ct)
-    {
-#define CASE(CT) \
-    case CT:     \
-        return Callback<CT>{}(std::forward<Args>(args)...);
-
-        CASE(qdb_ts_column_int64);
-        CASE(qdb_ts_column_double);
-        CASE(qdb_ts_column_timestamp);
-        CASE(qdb_ts_column_blob);
-        CASE(qdb_ts_column_string);
-        CASE(qdb_ts_column_symbol);
-
-    default:
-        throw qdb::not_implemented_exception{"Column type dispatch not handled: " + std::to_string(ct)};
-    };
-#undef CASE
-}
-
-}; // namespace qdb::dispatch

quasardb/double.hpp

@@ -1,87 +0,0 @@
-/*
- *
- * Official Python API
- *
- * Copyright (c) 2009-2024, quasardb SAS. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *    * Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *    * Neither the name of quasardb nor the names of its contributors may
- *      be used to endorse or promote products derived from this software
- *      without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY QUASARDB AND CONTRIBUTORS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#pragma once
-
-#include "entry.hpp"
-#include <qdb/double.h>
-
-namespace qdb
-{
-
-class double_entry : public expirable_entry
-{
-public:
-    double_entry(handle_ptr h, std::string a) noexcept
-        : expirable_entry{h, a}
-    {}
-
-public:
-    double get()
-    {
-        double result;
-        qdb::qdb_throw_if_error(*_handle, qdb_double_get(*_handle, _alias.c_str(), &result));
-        return result;
-    }
-
-    void put(double val)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_double_put(*_handle, _alias.c_str(), val, qdb_time_t{0}));
-    }
-
-    void update(double val)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_double_update(*_handle, _alias.c_str(), val, qdb_time_t{0}));
-    }
-
-    double add(double val)
-    {
-        double result;
-        qdb::qdb_throw_if_error(*_handle, qdb_double_add(*_handle, _alias.c_str(), val, &result));
-        return result;
-    }
-};
-
-template <typename Module>
-static inline void register_double(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::double_entry, qdb::expirable_entry>(m, "Double")  //
-        .def(py::init<qdb::handle_ptr, std::string>())                //
-        .def("get", &qdb::double_entry::get)                          //
-        .def("put", &qdb::double_entry::put, py::arg("double"))       //
-        .def("update", &qdb::double_entry::update, py::arg("double")) //
-        .def("add", &qdb::double_entry::add, py::arg("addend"))       //
-        ;                                                             //
-}
-
-} // namespace qdb

quasardb/entry.hpp

@@ -1,273 +0,0 @@
-/*
- *
- * Official Python API
- *
- * Copyright (c) 2009-2024, quasardb SAS. All rights reserved.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *    * Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *    * Neither the name of quasardb nor the names of its contributors may
- *      be used to endorse or promote products derived from this software
- *      without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY QUASARDB AND CONTRIBUTORS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#pragma once
-
-#include "error.hpp"
-#include "handle.hpp"
-#include "pytypes.hpp"
-#include "utils.hpp"
-#include <qdb/tag.h>
-#include "convert/value.hpp"
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <chrono>
-
-namespace qdb
-{
-
-using hostname = std::pair<std::string, unsigned short>;
-
-class entry
-{
-
-public:
-    struct metadata
-    {
-        metadata() noexcept
-        {}
-
-        // we need to adjust for timezone as quasardb is UTC and pybind11 will
-        // assume local date time points
-        metadata(qdb_entry_metadata_t const & md) noexcept
-            : type{md.type}
-            , size{md.size}
-            , modification_time{md.modification_time.tv_sec}
-            , expiry_time{md.expiry_time.tv_sec}
-        {}
-
-        qdb_entry_type_t type{qdb_entry_uninitialized};
-        qdb_uint_t size{0};
-        qdb_timespec_t modification_time;
-        qdb_timespec_t expiry_time;
-    };
-
-public:
-    entry(handle_ptr h, std::string a)
-        : _handle{h}
-        , _alias{a}
-    {}
-
-public:
-    bool attach_tag(const std::string & tag)
-    {
-        const qdb_error_t err = qdb_attach_tag(*_handle, _alias.c_str(), tag.c_str());
-
-        if (err != qdb_e_tag_already_set) [[likely]]
-        {
-            qdb_throw_if_error(*_handle, err);
-        }
-        return err != qdb_e_tag_already_set;
-    }
-
-    void attach_tags(const std::vector<std::string> & tags)
-    {
-        std::vector<const char *> tag_pointers(tags.size());
-
-        std::transform(tags.cbegin(), tags.cend(), tag_pointers.begin(),
-            [](const std::string & s) { return s.c_str(); });
-
-        qdb::qdb_throw_if_error(*_handle,
-            qdb_attach_tags(*_handle, _alias.c_str(), tag_pointers.data(), tag_pointers.size()));
-    }
-
-    bool detach_tag(const std::string & tag)
-    {
-        const qdb_error_t err = qdb_detach_tag(*_handle, _alias.c_str(), tag.c_str());
-
-        if (err != qdb_e_tag_not_set) [[likely]]
-        {
-            qdb_throw_if_error(*_handle, err);
-        }
-
-        return err != qdb_e_tag_not_set;
-    }
-
-    void detach_tags(const std::vector<std::string> & tags)
-    {
-        std::vector<const char *> tag_pointers(tags.size());
-
-        std::transform(tags.cbegin(), tags.cend(), tag_pointers.begin(),
-            [](const std::string & s) { return s.c_str(); });
-
-        qdb::qdb_throw_if_error(*_handle,
-            qdb_detach_tags(*_handle, _alias.c_str(), tag_pointers.data(), tag_pointers.size()));
-    }
-
-    bool has_tag(const std::string & tag)
-    {
-        return qdb_has_tag(*_handle, _alias.c_str(), tag.c_str()) == qdb_e_ok;
-    }
-
-    std::vector<std::string> get_tags()
-    {
-        const char ** tags = nullptr;
-        size_t tag_count   = 0;
-
-        qdb::qdb_throw_if_error(*_handle, qdb_get_tags(*_handle, _alias.c_str(), &tags, &tag_count));
-
-        return convert_strings_and_release(_handle, tags, tag_count);
-    }
-
-public:
-    void remove()
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_remove(*_handle, _alias.c_str()));
-    }
-
-    inline qdb::hostname get_location() const
-    {
-        qdb_remote_node_t rn;
-
-        qdb::qdb_throw_if_error(*_handle, qdb_get_location(*_handle, _alias.c_str(), &rn));
-
-        qdb::hostname res{rn.address, rn.port};
-
-        qdb_release(*_handle, &rn);
-
-        return res;
-    }
-
-    inline bool exists() const
-    {
-        // There isn't an official way to do it, but quite reliable a way is
-        // to just check whether an entry has metadata.
-        qdb_entry_metadata_t md;
-        qdb_error_t err = qdb_get_metadata(*_handle, _alias.c_str(), &md);
-
-        return err == qdb_e_ok;
-    }
-
-    inline metadata get_metadata() const
-    {
-        qdb_entry_metadata_t md;
-
-        qdb::qdb_throw_if_error(*_handle, qdb_get_metadata(*_handle, _alias.c_str(), &md));
-
-        return metadata{md};
-    }
-
-    inline qdb_entry_type_t get_entry_type() const
-    {
-        return get_metadata().type;
-    }
-
-    const std::string & get_name() const noexcept
-    {
-        return _alias;
-    }
-
-protected:
-    handle_ptr _handle;
-    std::string _alias;
-};
-
-class expirable_entry : public entry
-{
-public:
-    expirable_entry(handle_ptr h, std::string a)
-        : entry{h, a}
-    {}
-
-public:
-    static qdb_time_t from_pydatetime(qdb::pydatetime const & dt) noexcept
-    {
-        return qdb::convert::value<qdb::pydatetime, qdb_time_t>(dt);
-    }
-
-public:
-    void expires_at(const qdb::pydatetime & expiry_time)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_expires_at(*_handle, _alias.c_str(), from_pydatetime(expiry_time)));
-    }
-
-    void expires_from_now(std::chrono::milliseconds expiry_delta)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_expires_from_now(*_handle, _alias.c_str(), expiry_delta.count()));
-    }
-
-    qdb::pydatetime get_expiry_time()
-    {
-        return convert::value<qdb_timespec_t, qdb::pydatetime>(get_metadata().expiry_time);
-    }
-};
-
-template <typename Module>
-static inline void register_entry(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::entry> e{m, "Entry"};
-
-    py::enum_<qdb_entry_type_t>{e, "Type", py::arithmetic(), "Entry type"} //
-        .value("Uninitialized", qdb_entry_uninitialized)                   //
-        .value("Integer", qdb_entry_integer)                               //
-        .value("HashSet", qdb_entry_hset)                                  //
-        .value("Tag", qdb_entry_tag)                                       //
-        .value("Deque", qdb_entry_deque)                                   //
-        .value("Stream", qdb_entry_stream)                                 //
-        .value("Timeseries", qdb_entry_ts)                                 //
-        ;
-
-    e.def(py::init<qdb::handle_ptr, std::string>())         //
-        .def("attach_tag", &qdb::entry::attach_tag)         //
-        .def("attach_tags", &qdb::entry::attach_tags)       //
-        .def("detach_tag", &qdb::entry::detach_tag)         //
-        .def("detach_tags", &qdb::entry::detach_tags)       //
-        .def("has_tag", &qdb::entry::has_tag)               //
-        .def("get_tags", &qdb::entry::get_tags)             //
-        .def("remove", &qdb::entry::remove)                 //
-        .def("exists", &qdb::entry::exists,                 //
-            "Returns true if the entry exists")             //
-        .def("get_location", &qdb::entry::get_location)     //
-        .def("get_entry_type", &qdb::entry::get_entry_type) //
-        .def("get_metadata", &qdb::entry::get_metadata)     //
-        .def("get_name", &qdb::entry::get_name)             //
-        ;
-
-    py::class_<qdb::entry::metadata>{e, "Metadata"}                                   //
-        .def(py::init<>())                                                            //
-        .def_readwrite("type", &qdb::entry::metadata::type)                           //
-        .def_readwrite("size", &qdb::entry::metadata::size)                           //
-        .def_readwrite("modification_time", &qdb::entry::metadata::modification_time) //
-        .def_readwrite("expiry_time", &qdb::entry::metadata::expiry_time)             //
-        ;
-
-    py::class_<qdb::expirable_entry, qdb::entry>{m, "ExpirableEntry"}     //
-        .def(py::init<qdb::handle_ptr, std::string>())                    //
-        .def("expires_at", &qdb::expirable_entry::expires_at)             //
-        .def("expires_from_now", &qdb::expirable_entry::expires_from_now) //
-        .def("get_expiry_time", &qdb::expirable_entry::get_expiry_time)   //
-        ;
-}
-
-} // namespace qdb