Cython 3.2.0__cp39-abi3-win32.whl

Cython/Utility/CConvert.pyx

@@ -0,0 +1,134 @@
+#################### FromPyStructUtility ####################
+
+cdef extern from *:
+    ctypedef struct PyTypeObject:
+        char* tp_name
+    PyTypeObject *Py_TYPE(obj)
+    bint PyMapping_Check(obj)
+    object PyErr_Format(exc, const char *format, ...)
+    int __Pyx_RaiseUnexpectedTypeError(const char *expected, object obj) except 0
+
+@cname("{{funcname}}")
+cdef {{struct_type}} {{funcname}}(obj) except *:
+    cdef {{struct_type}} result
+    if not PyMapping_Check(obj):
+        __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj)
+
+    {{for member in var_entries:}}
+    try:
+        value = obj['{{member.name}}']
+    except KeyError:
+        raise ValueError("No value specified for struct attribute '{{member.name}}'")
+    result.{{member.name}} = value
+    {{endfor}}
+    return result
+
+
+#################### FromPyUnionUtility ####################
+
+cdef extern from *:
+    ctypedef struct PyTypeObject:
+        char* tp_name
+    PyTypeObject *Py_TYPE(obj)
+    bint PyMapping_Check(obj)
+    object PyErr_Format(exc, const char *format, ...)
+    int __Pyx_RaiseUnexpectedTypeError(const char *expected, object obj) except 0
+
+@cname("{{funcname}}")
+cdef {{struct_type}} {{funcname}}(obj) except *:
+    cdef {{struct_type}} result
+    cdef Py_ssize_t length
+    if not PyMapping_Check(obj):
+        __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj)
+
+    last_found = None
+    length = len(obj)
+    if length:
+        {{for member in var_entries:}}
+        if '{{member.name}}' in obj:
+            if last_found is not None:
+                raise ValueError("More than one union attribute passed: '%s' and '%s'" % (last_found, '{{member.name}}'))
+            last_found = '{{member.name}}'
+            result.{{member.cname}} = obj['{{member.name}}']
+            length -= 1
+            if not length:
+                return result
+        {{endfor}}
+    if last_found is None:
+        raise ValueError("No value specified for any of the union attributes (%s)" %
+                         '{{", ".join(member.name for member in var_entries)}}')
+    return result
+
+
+#################### cfunc.to_py ####################
+
+@cname("{{cname}}")
+cdef object {{cname}}({{return_type.ctype}} (*f)({{ ', '.join(arg.type_cname for arg in args) }}) {{except_clause}}):
+    def wrap({{ ', '.join('{arg.ctype} {arg.name}'.format(arg=arg) for arg in args) }}):
+        """wrap({{', '.join(('{arg.name}: {arg.type_displayname}'.format(arg=arg) if arg.type_displayname else arg.name) for arg in args)}}){{if return_type.type_displayname}} -> {{return_type.type_displayname}}{{endif}}"""
+        {{'' if return_type.type.is_void else 'return '}}f({{ ', '.join(arg.name for arg in args) }})
+    return wrap
+
+
+#################### carray.from_py ####################
+
+cdef extern from *:
+    object PyErr_Format(exc, const char *format, ...)
+
+@cname("{{cname}}")
+cdef int {{cname}}(object o, {{base_type}} *v, Py_ssize_t length) except -1:
+    cdef Py_ssize_t i = length
+    try:
+        i = len(o)
+    except (TypeError, OverflowError):
+        pass
+    if i == length:
+        for i, item in enumerate(o):
+            if i >= length:
+                break
+            v[i] = item
+        else:
+            i += 1  # convert index to length
+            if i == length:
+                return 0
+
+    PyErr_Format(
+        IndexError,
+        ("too many values found during array assignment, expected %zd"
+         if i >= length else
+         "not enough values found during array assignment, expected %zd, got %zd"),
+        length, i)
+
+
+#################### carray.to_py ####################
+
+cdef extern from *:
+    void Py_INCREF(object o)
+    tuple PyTuple_New(Py_ssize_t size)
+    list PyList_New(Py_ssize_t size)
+    int __Pyx_PyTuple_SET_ITEM(object  p, Py_ssize_t pos, object o) except -1
+    int __Pyx_PyList_SET_ITEM(object  p, Py_ssize_t pos, object o) except -1
+
+
+@cname("{{cname}}")
+cdef inline list {{cname}}({{base_type}} *v, Py_ssize_t length):
+    cdef Py_ssize_t i
+    cdef object value
+    l = PyList_New(length)
+    for i in range(length):
+        value = v[<size_t> i]
+        Py_INCREF(value)
+        __Pyx_PyList_SET_ITEM(l, i, value)
+    return l
+
+
+@cname("{{to_tuple_cname}}")
+cdef inline tuple {{to_tuple_cname}}({{base_type}} *v, Py_ssize_t length):
+    cdef Py_ssize_t i
+    cdef object value
+    t = PyTuple_New(length)
+    for i in range(length):
+        value = v[<size_t> i]
+        Py_INCREF(value)
+        __Pyx_PyTuple_SET_ITEM(t, i, value)
+    return t

Cython/Utility/CMath.c

@@ -0,0 +1,104 @@
+
+/////////////// CDivisionWarning.proto ///////////////
+
+static int __Pyx_cdivision_warning(const char *, int); /* proto */
+
+/////////////// CDivisionWarning ///////////////
+
+static int __Pyx_cdivision_warning(const char *filename, int lineno) {
+#if CYTHON_COMPILING_IN_PYPY
+    // avoid compiler warnings
+    filename++; lineno++;
+    return PyErr_Warn(PyExc_RuntimeWarning,
+                     "division with oppositely signed operands, C and Python semantics differ");
+#else
+    return PyErr_WarnExplicit(PyExc_RuntimeWarning,
+                              "division with oppositely signed operands, C and Python semantics differ",
+                              filename,
+                              lineno,
+                              __Pyx_MODULE_NAME,
+                              NULL);
+#endif
+}
+
+
+/////////////// DivInt.proto ///////////////
+
+static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s, %(type)s, int b_is_constant); /* proto */
+
+/////////////// DivInt ///////////////
+
+static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s a, %(type)s b, int b_is_constant) {
+    %(type)s q = a / b;
+    %(type)s r = a - q*b;
+    %(type)s adapt_python = (b_is_constant ?
+        // Take advantage of constant folding for 'b'.
+        ((r != 0) & ((r < 0) ^ (b < 0))) :
+        ((r != 0) & ((r ^ b) < 0))
+    );
+    return q - adapt_python;
+}
+
+
+/////////////// ModInt.proto ///////////////
+
+static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s, int b_is_constant); /* proto */
+
+/////////////// ModInt ///////////////
+
+static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b, int b_is_constant) {
+    %(type)s r = a %% b;
+    %(type)s adapt_python = (b_is_constant ?
+        // Take advantage of constant folding for 'b'.
+        ((r != 0) & ((r < 0) ^ (b < 0))) :
+        ((r != 0) & ((r ^ b) < 0))
+    );
+    return r + adapt_python * b;
+}
+
+
+/////////////// ModFloat.proto ///////////////
+
+static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s, int b_is_constant); /* proto */
+
+/////////////// ModFloat ///////////////
+
+static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b, int b_is_constant) {
+    CYTHON_UNUSED_VAR(b_is_constant);
+    %(type)s r = fmod%(math_h_modifier)s(a, b);
+    r += ((r != 0) & ((r < 0) ^ (b < 0))) * b;
+    return r;
+}
+
+
+/////////////// IntPow.proto ///////////////
+
+static CYTHON_INLINE %(type)s %(func_name)s(%(type)s, %(type)s); /* proto */
+
+/////////////// IntPow ///////////////
+
+static CYTHON_INLINE %(type)s %(func_name)s(%(type)s b, %(type)s e) {
+    %(type)s t = b;
+    switch (e) {
+        case 3:
+            t *= b;
+        CYTHON_FALLTHROUGH;
+        case 2:
+            t *= b;
+        CYTHON_FALLTHROUGH;
+        case 1:
+            return t;
+        case 0:
+            return 1;
+    }
+    #if %(signed)s
+    if (unlikely(e<0)) return 0;
+    #endif
+    t = 1;
+    while (likely(e)) {
+        t *= (b * (e&1)) | ((~e)&1);    /* 1 or b */
+        b *= b;
+        e >>= 1;
+    }
+    return t;
+}

Cython/Utility/CommonStructures.c

@@ -0,0 +1,226 @@
+/////////////// FetchSharedCythonModule.proto ///////
+
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/////////////// FetchSharedCythonModule ////////////
+//@requires: ModuleSetupCode.c::AddModuleRef
+
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME);
+}
+
+/////////////// FetchCommonType.proto ///////////////
+
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases);
+
+/////////////// FetchCommonType ///////////////
+//@requires:ExtensionTypes.c::FixUpExtensionType
+//@requires: FetchSharedCythonModule
+//@requires:StringTools.c::IncludeStringH
+//@requires:Builtins.c::dict_setdefault
+
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases);
+    if (result && metaclass) {
+        PyObject *old_tp = (PyObject*)Py_TYPE(result);
+    Py_INCREF((PyObject*)metaclass);
+#if __PYX_LIMITED_VERSION_HEX >= 0x03090000
+        Py_SET_TYPE(result, metaclass);
+#else
+        result->ob_type = metaclass;
+#endif
+        Py_DECREF(old_tp);
+    }
+    return result;
+}
+#else
+#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b)
+#endif
+
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t expected_basicsize) {
+    Py_ssize_t basicsize;
+
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+
+    if (expected_basicsize == 0) {
+        return 0; // size is inherited, nothing useful to check
+    }
+
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_basicsize;
+    py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+    if (unlikely(!py_basicsize)) return -1;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = NULL;
+    if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1;
+#else
+    basicsize = ((PyTypeObject*) cached_type)->tp_basicsize;
+#endif
+
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name;
+    int get_item_ref_result;
+    // get the final part of the object name (after the last dot)
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+
+    py_object_name = PyUnicode_FromString(object_name);
+    if (!py_object_name) return NULL;
+
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) goto done;
+    abi_module_dict = PyModule_GetDict(abi_module);
+    if (!abi_module_dict) goto done;
+
+
+    get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type);
+    if (get_item_ref_result == 1) {
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    } else if (unlikely(get_item_ref_result == -1)) {
+        goto bad;
+    }
+
+    // Without module-state, pass the ABI module reference to avoid keeping the user module alive by foreign type usages.
+    // With module-state it's important to keep the user module alive though.
+    cached_type = __Pyx_PyType_FromMetaclass(
+        metaclass,
+        CYTHON_USE_MODULE_STATE ? module : abi_module,
+        spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+
+    new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type);
+    if (unlikely(new_cached_type != cached_type)) {
+        if (unlikely(!new_cached_type)) goto bad;
+        // race to initialize it - use the value that's already been set.
+        Py_DECREF(cached_type);
+        cached_type = new_cached_type;
+
+        if (__Pyx_VerifyCachedType(
+                cached_type,
+                object_name,
+                spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    } else {
+        Py_DECREF(new_cached_type);
+    }
+
+done:
+    Py_XDECREF(abi_module);
+    Py_DECREF(py_object_name);
+    // NOTE: always returns owned reference, or NULL on error
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+
+//////////////////// CommonTypesMetaclass.module_state_decls ////////////////////
+
+PyTypeObject *__pyx_CommonTypesMetaclassType;
+
+//////////////////// CommonTypesMetaclass.module_state_traverse ///////////////////
+
+Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType);
+
+//////////////////// CommonTypesMetaclass.module_state_clear ///////////////////
+
+Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType);
+
+//////////////////// CommonTypesMetaclass.init //////////////////
+//@substitute: naming
+
+if (likely(__pyx_CommonTypesMetaclass_init($module_cname) == 0)); else
+
+/////////////////////////// CommonTypesMetaclass.proto ////////////////////////
+
+static int __pyx_CommonTypesMetaclass_init(PyObject *module); /* proto */
+
+#define __Pyx_CommonTypesMetaclass_USED
+
+//////////////////// CommonTypesMetaclass ////////////////////
+//@requires: FetchCommonType
+//@substitute: naming
+
+static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) {
+    return PyUnicode_FromString(__PYX_ABI_MODULE_NAME);
+}
+
+#if __PYX_LIMITED_VERSION_HEX < 0x030A0000
+static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) {
+    PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types");
+    return NULL;
+}
+
+static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) {
+    PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable");
+    return -1;
+}
+#endif
+
+static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = {
+    {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL},
+    {0, 0, 0, 0, 0}
+};
+
+static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = {
+    {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset},
+    #if __PYX_LIMITED_VERSION_HEX < 0x030A0000
+    {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call},
+    {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call},
+    {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr},
+    #endif
+    {0, 0}
+};
+
+static PyType_Spec __pyx_CommonTypesMetaclass_spec = {
+    __PYX_TYPE_MODULE_PREFIX "_common_types_metatype",
+    0,
+    0,
+    Py_TPFLAGS_IMMUTABLETYPE |
+    Py_TPFLAGS_DISALLOW_INSTANTIATION |
+    Py_TPFLAGS_DEFAULT, /*tp_flags*/
+    __pyx_CommonTypesMetaclass_slots
+};
+
+static int __pyx_CommonTypesMetaclass_init(PyObject *module) {
+    $modulestatetype_cname *mstate = __Pyx_PyModule_GetState(module);
+    PyObject *bases = PyTuple_Pack(1, &PyType_Type);
+    if (unlikely(!bases)) {
+        return -1;
+    }
+    mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases);
+    Py_DECREF(bases);
+    if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) {
+        return -1;
+    }
+    return 0;
+}