pyopencl 2024.2.2__cp311-cp311-macosx_11_0_arm64.whl → 2024.2.5__cp311-cp311-macosx_11_0_arm64.whl

pyopencl-2024.2.2.data/data/src/wrap_helpers.hpp

@@ -1,213 +0,0 @@
-// Wrapper-helping odds and ends
-//
-// Copyright (C) 2009 Andreas Kloeckner
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-
-
-#ifndef PYCUDA_WRAP_HELPERS_HEADER_SEEN
-#define PYCUDA_WRAP_HELPERS_HEADER_SEEN
-
-
-#include <nanobind/nanobind.h>
-#include <nanobind/stl/string.h>
-#include <nanobind/stl/shared_ptr.h>
-#include <nanobind/ndarray.h>
-
-
-namespace py = nanobind;
-
-
-#define ENUM_VALUE(NAME) \
-  value(#NAME, NAME)
-
-// {{{ DEF_SIMPLE_XXX
-
-#define DEF_SIMPLE_METHOD(NAME) \
-  def(#NAME, &cls::NAME)
-
-#define DEF_SIMPLE_STATIC_METHOD(NAME) \
-  def_static(#NAME, &cls::NAME)
-
-#define DEF_SIMPLE_METHOD_WITH_ARGS(NAME, ARGS) \
-  def(#NAME, &cls::NAME, boost::python::args ARGS)
-
-#define DEF_SIMPLE_FUNCTION(NAME) \
-  m.def(#NAME, &NAME)
-
-#define DEF_SIMPLE_FUNCTION_WITH_ARGS(NAME, ARGS) \
-  m.def(#NAME, &NAME, py::args ARGS)
-
-#define DEF_SIMPLE_RO_MEMBER(NAME) \
-  def_readonly(#NAME, &cls::m_##NAME)
-
-#define DEF_SIMPLE_RW_MEMBER(NAME) \
-  def_readwrite(#NAME, &cls::m_##NAME)
-
-// }}}
-
-// {{{ COPY_PY_XXX
-
-#define COPY_PY_LIST(TYPE, NAME) \
-  { \
-    for (auto it: py_##NAME) \
-      NAME.push_back(py::cast<TYPE>(it)); \
-  }
-
-#define COPY_PY_ARRAY(FUNC_NAME, TYPE, NAME, COUNTER) \
-  { \
-    COUNTER = 0; \
-    for (auto it: py_##NAME) \
-    { \
-      if (COUNTER == NAME.size()) \
-        throw error(FUNC_NAME, \
-            CL_INVALID_VALUE, "too many entries in " #NAME " argument"); \
-      NAME[COUNTER++] = py::cast<TYPE>(it); \
-    } \
-  }
-
-#define COPY_PY_COORD_TRIPLE(NAME) \
-  size_t NAME[3] = {0, 0, 0}; \
-  { \
-    py::sequence py_seq_##NAME = py::cast<py::sequence>(py_##NAME); \
-    size_t my_len = len(py_seq_##NAME); \
-    if (my_len > 3) \
-      throw error("transfer", CL_INVALID_VALUE, #NAME "has too many components"); \
-    for (size_t i = 0; i < my_len; ++i) \
-      NAME[i] = py::cast<size_t>(py_seq_##NAME[i]); \
-  }
-
-#define COPY_PY_PITCH_TUPLE(NAME) \
-  size_t NAME[2] = {0, 0}; \
-  if (py_##NAME.ptr() != Py_None) \
-  { \
-    py::sequence py_seq_##NAME = py::cast<py::sequence>(py_##NAME); \
-    size_t my_len = len(py_seq_##NAME); \
-    if (my_len > 2) \
-      throw error("transfer", CL_INVALID_VALUE, #NAME "has too many components"); \
-    for (size_t i = 0; i < my_len; ++i) \
-      NAME[i] = py::cast<size_t>(py_seq_##NAME[i]); \
-  }
-
-#define COPY_PY_REGION_TRIPLE(NAME) \
-  size_t NAME[3] = {1, 1, 1}; \
-  { \
-    py::sequence py_seq_##NAME = py::cast<py::sequence>(py_##NAME); \
-    size_t my_len = len(py_seq_##NAME); \
-    if (my_len > 3) \
-      throw error("transfer", CL_INVALID_VALUE, #NAME "has too many components"); \
-    for (size_t i = 0; i < my_len; ++i) \
-      NAME[i] = py::cast<size_t>(py_seq_##NAME[i]); \
-  }
-
-// }}}
-
-#define PYOPENCL_PARSE_NUMPY_ARRAY_SPEC \
-    PyArray_Descr *tp_descr; \
-    if (PyArray_DescrConverter(dtype.ptr(), &tp_descr) != NPY_SUCCEED) \
-      throw py::python_error(); \
-    \
-    std::vector<npy_intp> shape; \
-    try \
-    { \
-      shape.push_back(py::cast<npy_intp>(py_shape)); \
-    } \
-    catch (py::cast_error &) \
-    { \
-      COPY_PY_LIST(npy_intp, shape); \
-    } \
-    \
-    NPY_ORDER order = NPY_CORDER; \
-    PyArray_OrderConverter(py_order.ptr(), &order); \
-    \
-    int ary_flags = 0; \
-    if (order == NPY_FORTRANORDER) \
-      ary_flags |= NPY_FARRAY; \
-    else if (order == NPY_CORDER) \
-      ary_flags |= NPY_CARRAY; \
-    else \
-      throw std::runtime_error("unrecognized order specifier"); \
-    \
-    std::vector<npy_intp> strides; \
-    if (py_strides.ptr() != Py_None) \
-    { \
-      COPY_PY_LIST(npy_intp, strides); \
-    }
-
-#define PYOPENCL_RETURN_VECTOR(ITEMTYPE, NAME) \
-  { \
-    py::list pyopencl_result; \
-    for (ITEMTYPE item: NAME) \
-      pyopencl_result.append(item); \
-    return pyopencl_result; \
-  }
-
-namespace
-{
-  template <typename T>
-  inline py::object handle_from_new_ptr(T *ptr)
-  {
-    return py::cast(ptr, py::rv_policy::take_ownership);
-  }
-
-  template <typename T, typename ClType>
-  inline T *from_int_ptr(intptr_t obj_ref, bool retain)
-  {
-    ClType clobj = (ClType) obj_ref;
-    return new T(clobj, retain);
-  }
-
-  template <typename T>
-  inline intptr_t to_int_ptr(T const &obj)
-  {
-    return (intptr_t) obj.data();
-  }
-}
-
-#define PYOPENCL_EXPOSE_TO_FROM_INT_PTR(CL_TYPENAME) \
-  .def_static("from_int_ptr", from_int_ptr<cls, CL_TYPENAME>, \
-      py::arg("int_ptr_value"), \
-      py::arg("retain")=true, \
-      "(static method) Return a new Python object referencing the C-level " \
-      ":c:type:`" #CL_TYPENAME "` object at the location pointed to " \
-      "by *int_ptr_value*. The relevant ``clRetain*`` function " \
-      "will be called if *retain* is True." \
-      "If the previous owner of the object will *not* release the reference, " \
-      "*retain* should be set to *False*, to effectively transfer ownership to " \
-      ":mod:`pyopencl`." \
-      "\n\n.. versionadded:: 2013.2\n" \
-      "\n\n.. versionchanged:: 2016.1\n\n    *retain* added.") \
-  .def_prop_ro("int_ptr", to_int_ptr<cls>, \
-      "Return an integer corresponding to the pointer value " \
-      "of the underlying :c:type:`" #CL_TYPENAME "`. " \
-      "Use :meth:`from_int_ptr` to turn back into a Python object." \
-      "\n\n.. versionadded:: 2013.2\n") \
-
-#define PYOPENCL_EXPOSE_EQUALITY_TESTS \
-    /* this relies on nanobind overload resolution going in order of registration */ \
-    .def("__eq__", [](cls const &self, cls const &other) { return self == other; }) \
-    .def("__eq__", [](cls const &self, py::object obj) { return false; }, py::arg("obj").none())
-
-
-#endif
-
-// vim: foldmethod=marker