quasardb 3.13.6.post1__cp310-cp310-win_amd64.whl → 3.13.7__cp310-cp310-win_amd64.whl

quasardb/convert/array.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -79,8 +79,8 @@ struct convert_array;
 //
 /////
 template <typename From, typename To>
-    requires(concepts::dtype<From> && !concepts::delegate_dtype<From> && concepts::qdb_primitive<To>)
-struct convert_array<From, To>
+requires(concepts::dtype<From> && !concepts::delegate_dtype<From> && concepts::qdb_primitive<To>) struct
+    convert_array<From, To>
 {
     using value_type = typename From::value_type;
     static constexpr value_converter<From, To> const xform_{};
@@ -105,8 +105,7 @@ struct convert_array<From, To>
 //
 /////
 template <typename From, typename To>
-    requires(concepts::delegate_dtype<From> && concepts::qdb_primitive<To>)
-struct convert_array<From, To>
+requires(concepts::delegate_dtype<From> && concepts::qdb_primitive<To>) struct convert_array<From, To>
 {
     // Source value_type, e.g. std::int32_t
     using value_type = typename From::value_type;
@@ -145,8 +144,7 @@ struct convert_array<From, To>
 //
 /////
 template <typename From, typename To>
-    requires(concepts::qdb_primitive<From> && !concepts::delegate_dtype<To>)
-struct convert_array<From, To>
+requires(concepts::qdb_primitive<From> && !concepts::delegate_dtype<To>) struct convert_array<From, To>
 {
     static constexpr value_converter<From, To> const xform_{};
 
@@ -156,6 +154,49 @@ struct convert_array<From, To>
     };
 };
 
+/////
+//
+// qdb->numpy
+// "Delegate" transforms
+//
+// In some cases numpy's representations are more rich than what Quasardb's primitives
+// support, e.g. int32. In this case, we first transform this to the "delegate type",
+// int64, which can then figure out the rest.
+//
+// Input:  range of length N, type: qdb_primitive
+// Output: range of length N, dtype: To
+//
+/////
+template <typename From, typename To>
+requires(concepts::qdb_primitive<From> && concepts::delegate_dtype<To>) struct convert_array<From, To>
+{
+    // Destination value_type, e.g. std::int32_t
+    using value_type = typename To::value_type;
+
+    // Delegate dtype, e.g. traits::int64_dtype
+    using Delegate = typename To::delegate_type;
+
+    // Delegate value_type, e.g. std::int64_t
+    using delegate_value_type = typename Delegate::value_type;
+
+    static constexpr convert_array<From, Delegate> const delegate{};
+
+    [[nodiscard]] constexpr inline auto operator()() const noexcept
+    {
+        auto xform = [](value_type const & x) -> delegate_value_type {
+            if (To::is_null(x))
+            {
+                return Delegate::null_value();
+            }
+            else
+            {
+                return static_cast<delegate_value_type>(x);
+            }
+        };
+        return ranges::views::transform(xform) | delegate();
+    };
+};
+
 }; // namespace qdb::convert::detail
 
 namespace qdb::convert
@@ -225,4 +266,17 @@ static inline constexpr std::vector<To> masked_array(qdb::masked_array const & x
     return array<From, To>(xs.filled<From>());
 }
 
+// qdb -> numpy
+template <concepts::qdb_primitive From, concepts::dtype To, ranges::input_range R>
+requires(concepts::input_range_t<R, From>) static inline qdb::masked_array masked_array(R && xs)
+{
+    if (ranges::empty(xs)) [[unlikely]]
+    {
+        return {};
+    };
+
+    py::array xs_ = detail::to_array<To>(xs | detail::convert_array<From, To>{}());
+    return qdb::masked_array(xs_, qdb::masked_array::masked_null<To>(xs_));
+}
+
 }; // namespace qdb::convert

quasardb/convert/point.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -58,12 +58,10 @@ namespace py = pybind11;
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
-    requires(concepts::qdb_primitive<T>)
-using point_type = typename traits::qdb_value<T>::point_type;
+requires(concepts::qdb_primitive<T>) using point_type = typename traits::qdb_value<T>::point_type;
 
 template <typename T>
-    requires(concepts::qdb_point<T>)
-using primitive_type = typename traits::qdb_value<T>::primitive_type;
+requires(concepts::qdb_point<T>) using primitive_type = typename traits::qdb_value<T>::primitive_type;
 
 // Base declaration of pair-to-point function
 template <concepts::qdb_primitive T>
@@ -136,8 +134,7 @@ struct convert_point_array;
 //
 /////
 template <typename From, typename To>
-    requires(concepts::dtype<From> && concepts::qdb_primitive<To>)
-struct convert_point_array<From, To>
+requires(concepts::dtype<From> && concepts::qdb_primitive<To>) struct convert_point_array<From, To>
 {
     static constexpr convert_array<From, To> const value_delegate_{};
     static constexpr convert_array<traits::datetime64_ns_dtype, qdb_timespec_t> const ts_delegate_{};
@@ -176,8 +173,7 @@ struct convert_point_array<From, To>
 //
 /////
 template <typename From, typename To>
-    requires(concepts::qdb_primitive<From> && concepts::dtype<To>)
-struct convert_point_array<From, To>
+requires(concepts::qdb_primitive<From> && concepts::dtype<To>) struct convert_point_array<From, To>
 {
     static constexpr convert_array<From, To> const value_delegate_{};
     static constexpr convert_array<qdb_timespec_t, traits::datetime64_ns_dtype> const ts_delegate_{};
@@ -192,6 +188,7 @@ struct convert_point_array<From, To>
 
         auto timestamps_ = timestamps | ts_delegate_();
         auto values_     = values | value_delegate_();
+
         return std::make_pair(timestamps_, values_);
     }
 };
@@ -288,13 +285,21 @@ static inline std::vector<point_type<To>> point_array(
     return point_array<From, To>(timestamps, values.filled<From>());
 };
 
+// numpy -> qdb
+template <concepts::dtype From, concepts::qdb_primitive To>
+static inline std::vector<point_type<To>> point_array(
+    std::pair<py::array, qdb::masked_array> const & xs)
+{
+    return point_array<From, To>(std::get<0>(xs), std::get<1>(xs));
+};
+
 // qdb -> numpy
 //
 // Takes a range of qdb point structs (eg qdb_ts_double_point) and returns a pair of two
 // numpy ndarrays, one for timestamps and another for the values.
 template <concepts::qdb_primitive From, concepts::dtype To, ranges::input_range R>
-    requires(concepts::input_range_t<R, point_type<From>>)
-static inline std::pair<py::array, qdb::masked_array> point_array(R && xs)
+requires(concepts::input_range_t<R, point_type<From>>) static inline std::pair<py::array,
+    qdb::masked_array> point_array(R && xs)
 {
     if (ranges::empty(xs)) [[unlikely]]
     {

quasardb/convert/range.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -32,6 +32,7 @@
 
 #include "../concepts.hpp"
 #include "../error.hpp"
+#include "unicode.hpp"
 #include "util.hpp"
 #include <range/v3/algorithm/all_of.hpp>
 #include <range/v3/algorithm/copy.hpp>
@@ -51,8 +52,7 @@ namespace qdb::convert::detail
 namespace py = pybind11;
 
 template <concepts::dtype DType>
-    requires(concepts::variable_width_dtype<DType>)
-struct clean_stride
+requires(concepts::variable_width_dtype<DType>) struct clean_stride
 {
     using stride_type = typename DType::stride_type;      // e.g. std::u32string
     using value_type  = typename stride_type::value_type; // e.g. wchar_t
@@ -60,8 +60,8 @@ struct clean_stride
     static constexpr value_type const null_value_ = DType::null_value();
 
     template <concepts::input_range_t<value_type> InputRange>
-        requires(ranges::sized_range<InputRange>)
-    inline decltype(auto) operator()(InputRange && stride) const noexcept
+    requires(ranges::sized_range<InputRange>) inline decltype(auto) operator()(
+        InputRange && stride) const noexcept
     {
 
         auto first = ranges::begin(stride);
@@ -83,8 +83,7 @@ struct clean_stride
 };
 
 template <concepts::dtype DType>
-    requires(concepts::fixed_width_dtype<DType>)
-inline decltype(auto) to_range(py::array const & xs)
+requires(concepts::fixed_width_dtype<DType>) inline decltype(auto) to_range(py::array const & xs)
 {
     // Lowest-level codepoint representation inside numpy, e.g. wchar_t for unicode
     // or short for int16.
@@ -98,17 +97,15 @@ inline decltype(auto) to_range(py::array const & xs)
     py::ssize_t stride_size{0};
     switch (xs.ndim())
     {
-    // This can happen in case an array contains only a single number, then it will
-    // not have any dimensions. In this case, it's best to just use the itemsize as
-    // the stride size, because we'll not have to forward the iterator anyway.
-    [[unlikely]] case 0:
-        stride_size = xs.itemsize();
+        // This can happen in case an array contains only a single number, then it will
+        // not have any dimensions. In this case, it's best to just use the itemsize as
+        // the stride size, because we'll not have to forward the iterator anyway.
+        [[unlikely]] case 0 : stride_size = xs.itemsize();
         break;
 
-    // Default case: use stride size of the first (and only) dimension. Most of the
-    //               time this will be identical to the itemsize.
-    [[likely]] case 1:
-        stride_size = xs.strides(0);
+        // Default case: use stride size of the first (and only) dimension. Most of the
+        //               time this will be identical to the itemsize.
+        [[likely]] case 1 : stride_size = xs.strides(0);
         break;
     default:
         throw qdb::incompatible_type_exception{
@@ -133,8 +130,7 @@ inline decltype(auto) to_range(py::array const & xs)
 
 // Variable length encoding: split into chunks of <itemsize() / codepoint_size>
 template <concepts::dtype DType>
-    requires(concepts::variable_width_dtype<DType>)
-inline decltype(auto) to_range(py::array const & xs)
+requires(concepts::variable_width_dtype<DType>) inline decltype(auto) to_range(py::array const & xs)
 {
     using stride_type = typename DType::stride_type;
     using value_type  = typename stride_type::value_type;
@@ -190,8 +186,7 @@ inline decltype(auto) to_range(py::array const & xs)
  * Converts range R to np.ndarray of dtype DType. Copies underlying data.
  */
 template <concepts::dtype DType, ranges::input_range R>
-    requires(concepts::fixed_width_dtype<DType>)
-inline py::array to_array(R && xs)
+requires(concepts::fixed_width_dtype<DType>) inline py::array to_array(R && xs)
 {
     using value_type = typename DType::value_type;
 
@@ -208,8 +203,7 @@ inline py::array to_array(R && xs)
  * Converts range R to np.ndarray of dtype DType. Copies underlying data.
  */
 template <concepts::dtype Dtype, ranges::input_range R>
-    requires(concepts::variable_width_dtype<Dtype>)
-inline py::array to_array(R && xs)
+requires(concepts::variable_width_dtype<Dtype>) inline py::array to_array(R && xs)
 {
     using out_char_type = typename Dtype::value_type;
 
@@ -274,9 +268,9 @@ inline py::array to_array(R && xs)
         static_assert(ranges::input_range<decltype(in)>);
         static_assert(ranges::output_range<decltype(out), out_char_type>);
 
-        assert(ranges::size(out) == stride_size);
-        assert(ranges::size(in) <= ranges::size(out));
-        assert(ranges::empty(in) == false);
+        // assert(ranges::size(out) == stride_size);
+        // assert(ranges::size(in) <= ranges::size(out));
+        // assert(ranges::empty(in) == false);
 
         ranges::copy(in, ranges::begin(out));
     });