xnd 0.2.0dev3

data/ext/ruby_xnd/xnd/python/xnd/docstrings.h

@@ -0,0 +1,129 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2017-2018, plures
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. Neither the name of the copyright holder 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 THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER OR 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.
+ */
+
+
+#include "pymacro.h"
+
+
+/******************************************************************************/
+/*                                Module                                      */
+/******************************************************************************/
+
+
+PyDoc_STRVAR(doc_module, "xnd module");
+
+
+
+/******************************************************************************/
+/*                             xnd properties                                 */
+/******************************************************************************/
+
+PyDoc_STRVAR(doc_value,
+"\n\
+Convert the in-memory value to a Python value.\n\
+\n\
+   >>> x = xnd([1, 2, 3, 4, 5])\n\
+   >>> x.value\n\
+   [1, 2, 3, 4, 5]\n\
+\n");
+
+PyDoc_STRVAR(doc_type,
+"\n\
+Return the type of the in-memory value.\n\
+\n\
+   >>> x = xnd([[1, 2, 3], [4, 5]])\n\
+   >>> x.type\n\
+   ndt(\"var * var * int64\")\n\
+\n");
+
+PyDoc_STRVAR(doc_ndim,
+"\n\
+Return the number of dimensions of the in-memory value.\n\
+\n\
+   >>> x = xnd([[(1, \"a\"), (2, \"b\")], [(3, \"x\"), (4, \"y\")]])\n\
+   >>> x.ndim\n\
+   2\n\
+\n");
+
+PyDoc_STRVAR(doc_align,
+"\n\
+Return the alignment of the memory block.\n\
+\n\
+   >>> t = \"2 * {a: uint8, b: float64, align=512}\"\n\
+   >>> x = xnd([{'a': 1, 'b': 2.0}, {'a': 2, 'b': 3.0}], type=t)\n\
+   >>> x.align\n\
+   512\n\
+\n");
+
+
+/******************************************************************************/
+/*                                xnd methods                                 */
+/******************************************************************************/
+
+PyDoc_STRVAR(doc_short_value,
+"short_value($self, /, maxshape=None)\n--\n\n\
+Convert the in-memory value to an abbreviated Python value.  Container types\n\
+are converted to maxshape-1 actual values followed by an Ellipsis.  If maxshape\n\
+is None, the representation is not abbreviated.\n\
+\n\
+    >>> x = xnd([1, 2, 3, 4, 5])\n\
+    >>> x.short_value(maxshape=3)\n\
+    [1, 2, ...]\n\
+\n");
+
+PyDoc_STRVAR(doc_empty,
+"empty($type, type, /)\n--\n\n\
+Class method that constructs a new xnd container according to the type\n\
+argument.  All values are initialized to zero.\n\
+\n\
+    >>> xnd.empty(\"10 * 2 * (int64, string, complex128)\")\n\
+    xnd([[(0, '', 0j), (0, '', 0j)], [(0, '', 0j), (0, '', 0j)],\n\
+         [(0, '', 0j), (0, '', 0j)], [(0, '', 0j), (0, '', 0j)],\n\
+         [(0, '', 0j), (0, '', 0j)], [(0, '', 0j), (0, '', 0j)],\n\
+         [(0, '', 0j), (0, '', 0j)], [(0, '', 0j), (0, '', 0j)],\n\
+         [(0, '', 0j), (0, '', 0j)], ...], type=\"10 * 2 * (int64, string, complex128)\")\n\
+\n");
+
+PyDoc_STRVAR(doc_from_buffer,
+"from_buffer($type, obj, /)\n--\n\n\
+Class method that constructs a new xnd container from an object that supports\n\
+the buffer protocol.\n\
+\n\
+    >>> xnd.from_buffer(b\"123\")\n\
+    xnd([49, 50, 51], type=\"3 * uint8\")\n\
+\n\
+    >>> import numpy as np\n\
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]])\n\
+    >>> xnd.from_buffer(a)\n\
+    xnd([[1, 2, 3], [4, 5, 6]], type=\"2 * 3 * int64\")\n\
+\n\
+\n");

data/ext/ruby_xnd/xnd/python/xnd/pyxnd.h

@@ -0,0 +1,200 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2017-2018, plures
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. Neither the name of the copyright holder 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 THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER OR 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.
+ */
+
+
+#ifndef PYXND_H
+#define PYXND_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include <Python.h>
+#include "ndtypes.h"
+#include "xnd.h"
+
+
+/****************************************************************************/
+/*                           MemoryBlock Object                             */
+/****************************************************************************/
+
+/* This object owns the memory that is shared by several xnd objects. It is
+   never exposed to the Python level.
+
+   The memory block is created by the primary xnd object on initialization.
+   Sub-views, slices etc. share the memory block.
+
+   PEP-3118 imports are supported.  At a later stage the mblock object will
+   potentially need to communicate with Arrow or other formats in order
+   to acquire and manage external memory blocks.
+*/
+
+/* Exposed here for the benefit of Numba. The API should not be regarded
+   stable across versions. */
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *type;    /* type owner */
+    xnd_master_t *xnd; /* memblock owner */
+    Py_buffer *view;   /* PEP-3118 imports */
+} MemoryBlockObject;
+
+
+/****************************************************************************/
+/*                                 xnd object                               */
+/****************************************************************************/
+
+/* Exposed here for the benefit of Numba. The API should not be regarded
+   stable across versions. */
+
+typedef struct {
+    PyObject_HEAD
+    MemoryBlockObject *mblock; /* owner of the primary type and memory block */
+    PyObject *type;            /* owner of the current type */
+    xnd_t xnd;                 /* typed view, does not own anything */
+} XndObject;
+
+#define TYPE_OWNER(v) (((XndObject *)v)->type)
+#define XND(v) (&(((XndObject *)v)->xnd))
+#define XND_INDEX(v) (((XndObject *)v)->xnd.index)
+#define XND_TYPE(v) (((XndObject *)v)->xnd.type)
+#define XND_PTR(v) (((XndObject *)v)->xnd.ptr)
+
+
+/****************************************************************************/
+/*                                Capsule API                               */
+/****************************************************************************/
+
+#define Xnd_CheckExact_INDEX 0
+#define Xnd_CheckExact_RETURN int
+#define Xnd_CheckExact_ARGS (const PyObject *)
+
+#define Xnd_Check_INDEX 1
+#define Xnd_Check_RETURN int
+#define Xnd_Check_ARGS (const PyObject *)
+
+#define CONST_XND_INDEX 2
+#define CONST_XND_RETURN const xnd_t *
+#define CONST_XND_ARGS (const PyObject *)
+
+#define Xnd_EmptyFromType_INDEX 3
+#define Xnd_EmptyFromType_RETURN PyObject *
+#define Xnd_EmptyFromType_ARGS (PyTypeObject *, ndt_t *t)
+
+#define Xnd_ViewMoveNdt_INDEX 4
+#define Xnd_ViewMoveNdt_RETURN PyObject *
+#define Xnd_ViewMoveNdt_ARGS (const PyObject *, ndt_t *t)
+
+#define Xnd_FromXnd_INDEX 5
+#define Xnd_FromXnd_RETURN PyObject *
+#define Xnd_FromXnd_ARGS (PyTypeObject *, xnd_t *x)
+
+#define Xnd_Subscript_INDEX 6
+#define Xnd_Subscript_RETURN PyObject *
+#define Xnd_Subscript_ARGS (const PyObject *self, const PyObject *key)
+
+#define Xnd_FromXndMoveType_INDEX 7
+#define Xnd_FromXndMoveType_RETURN PyObject *
+#define Xnd_FromXndMoveType_ARGS (const PyObject *xnd, xnd_t *x)
+
+#define Xnd_FromXndView_INDEX 8
+#define Xnd_FromXndView_RETURN PyObject *
+#define Xnd_FromXndView_ARGS (xnd_view_t *x)
+
+#define Xnd_GetType_INDEX 9
+#define Xnd_GetType_RETURN PyTypeObject *
+#define Xnd_GetType_ARGS (void)
+
+#define XND_MAX_API 10
+
+
+#ifdef XND_MODULE
+static Xnd_CheckExact_RETURN Xnd_CheckExact Xnd_CheckExact_ARGS;
+static Xnd_Check_RETURN Xnd_Check Xnd_Check_ARGS;
+static CONST_XND_RETURN CONST_XND CONST_XND_ARGS;
+static Xnd_EmptyFromType_RETURN Xnd_EmptyFromType Xnd_EmptyFromType_ARGS;
+static Xnd_ViewMoveNdt_RETURN Xnd_ViewMoveNdt Xnd_ViewMoveNdt_ARGS;
+static Xnd_FromXnd_RETURN Xnd_FromXnd Xnd_FromXnd_ARGS;
+static Xnd_Subscript_RETURN Xnd_Subscript Xnd_Subscript_ARGS;
+static Xnd_FromXndMoveType_RETURN Xnd_FromXndMoveType Xnd_FromXndMoveType_ARGS;
+static Xnd_FromXndView_RETURN Xnd_FromXndView Xnd_FromXndView_ARGS;
+static Xnd_GetType_RETURN Xnd_GetType Xnd_GetType_ARGS;
+#else
+static void **_xnd_api;
+
+#define Xnd_CheckExact \
+    (*(Xnd_CheckExact_RETURN (*)Xnd_CheckExact_ARGS) _xnd_api[Xnd_CheckExact_INDEX])
+
+#define Xnd_Check \
+    (*(Xnd_Check_RETURN (*)Xnd_Check_ARGS) _xnd_api[Xnd_Check_INDEX])
+
+#define CONST_XND \
+    (*(CONST_XND_RETURN (*)CONST_XND_ARGS) _xnd_api[CONST_XND_INDEX])
+
+#define Xnd_EmptyFromType \
+    (*(Xnd_EmptyFromType_RETURN (*)Xnd_EmptyFromType_ARGS) _xnd_api[Xnd_EmptyFromType_INDEX])
+
+#define Xnd_ViewMoveNdt \
+    (*(Xnd_ViewMoveNdt_RETURN (*)Xnd_ViewMoveNdt_ARGS) _xnd_api[Xnd_ViewMoveNdt_INDEX])
+
+#define Xnd_FromXnd \
+    (*(Xnd_FromXnd_RETURN (*)Xnd_FromXnd_ARGS) _xnd_api[Xnd_FromXnd_INDEX])
+
+#define Xnd_Subscript \
+    (*(Xnd_Subscript_RETURN (*)Xnd_Subscript_ARGS) _xnd_api[Xnd_Subscript_INDEX])
+
+#define Xnd_FromXndMoveType \
+    (*(Xnd_FromXndMoveType_RETURN (*)Xnd_FromXndMoveType_ARGS) _xnd_api[Xnd_FromXndMoveType_INDEX])
+
+#define Xnd_FromXndView \
+    (*(Xnd_FromXndView_RETURN (*)Xnd_FromXndView_ARGS) _xnd_api[Xnd_FromXndView_INDEX])
+
+#define Xnd_GetType \
+    (*(Xnd_GetType_RETURN (*)Xnd_GetType_ARGS) _xnd_api[Xnd_GetType_INDEX])
+
+static int
+import_xnd(void)
+{
+    _xnd_api = (void **)PyCapsule_Import("xnd._xnd._API", 0);
+    if (_xnd_api == NULL) {
+        return -1;
+    }
+
+    return 0;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PYXND_H */

data/ext/ruby_xnd/xnd/python/xnd/util.h

@@ -0,0 +1,182 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2017-2018, plures
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. Neither the name of the copyright holder 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 THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER OR 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.
+ */
+
+
+#ifndef UTIL_H
+#define UTIL_H
+
+
+#include <Python.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include "ndtypes.h"
+
+
+static inline Py_ssize_t
+safe_downcast(int64_t size)
+{
+#if SIZE_MAX < INT64_MAX
+    if (size > INT32_MAX) {
+        PyErr_SetString(PyExc_ValueError,
+            "sizes should never exceed INT32_MAX on 32-bit platforms");
+        return -1;
+    }
+#endif
+    return (Py_ssize_t)size;
+}
+
+static inline bool
+check_invariants(const ndt_t *t)
+{
+#if SIZE_MAX < INT64_MAX
+    return safe_downcast(t->datasize) >= 0;
+#else
+    (void)t;
+    return 1;
+#endif
+}
+
+static inline PyObject *
+list_new(int64_t size)
+{
+#if SIZE_MAX < INT64_MAX
+    Py_ssize_t n = safe_downcast(size);
+    return n < 0 ? NULL : PyList_New(n);
+#else
+    return PyList_New(size);
+#endif
+}
+
+static PyObject *
+tuple_new(int64_t size)
+{
+#if SIZE_MAX < INT64_MAX
+    Py_ssize_t n = safe_downcast(size);
+    return n < 0 ? NULL : PyTuple_New(n);
+#else
+    return PyTuple_New(size);
+#endif
+}
+
+static inline PyObject *
+unicode_from_kind_and_data(int kind, const void *buffer, int64_t size)
+{
+#if SIZE_MAX < INT64_MAX
+    Py_ssize_t n = safe_downcast(size);
+    return n < 0 ? NULL : PyUnicode_FromKindAndData(kind, buffer, n);
+#else
+    return PyUnicode_FromKindAndData(kind, buffer, size);
+#endif
+}
+
+static inline PyObject *
+bytes_from_string_and_size(const char *str, int64_t size)
+{
+#if SIZE_MAX < INT64_MAX
+    Py_ssize_t n = safe_downcast(size);
+    return n < 0 ? NULL : PyBytes_FromStringAndSize(str, n);
+#else
+    return PyBytes_FromStringAndSize(str, size);
+#endif
+}
+
+static inline int
+py_slice_get_indices_ex(PyObject *key, int64_t length,
+                        int64_t *start, int64_t *stop, int64_t *step,
+                        int64_t *slicelength)
+{
+    Py_ssize_t n, _start, _stop, _step, _slicelength;
+    int ret;
+
+    n = safe_downcast(length);
+    if (n < 0) {
+        return -1;
+    }
+
+    ret = PySlice_GetIndicesEx(key, n, &_start, &_stop, &_step, &_slicelength);
+    *start = _start;
+    *stop = _stop;
+    *step = _step;
+    *slicelength = _slicelength;
+
+    return ret;
+}
+
+/* PSF copyright: Written by Jim Hugunin and Chris Chase. */
+int
+pyslice_unpack(PyObject *_r,
+               Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
+{
+    PySliceObject *r = (PySliceObject*)_r;
+    /* this is harder to get right than you might think */
+
+    assert(PY_SSIZE_T_MIN + 1 <= -PY_SSIZE_T_MAX);
+
+    if (r->step == Py_None) {
+        *step = 1;
+    }
+    else {
+        if (!_PyEval_SliceIndex(r->step, step)) return -1;
+        if (*step == 0) {
+            PyErr_SetString(PyExc_ValueError,
+                            "slice step cannot be zero");
+            return -1;
+        }
+        /* Here *step might be -PY_SSIZE_T_MAX-1; in this case we replace it
+         * with -PY_SSIZE_T_MAX.  This doesn't affect the semantics, and it
+         * guards against later undefined behaviour resulting from code that
+         * does "step = -step" as part of a slice reversal.
+         */
+        if (*step < -PY_SSIZE_T_MAX)
+            *step = -PY_SSIZE_T_MAX;
+    }
+
+    if (r->start == Py_None) {
+        *start = *step < 0 ? PY_SSIZE_T_MAX : 0;
+    }
+    else {
+        if (!_PyEval_SliceIndex(r->start, start)) return -1;
+    }
+
+    if (r->stop == Py_None) {
+        *stop = *step < 0 ? PY_SSIZE_T_MIN : PY_SSIZE_T_MAX;
+    }
+    else {
+        if (!_PyEval_SliceIndex(r->stop, stop)) return -1;
+    }
+
+    return 0;
+}
+
+
+#endif /* UTIL_H */