Cython 3.3.0__cp315-cp315-win_amd64.whl

Cython/Utility/CpdefEnums.pyx

@@ -0,0 +1,119 @@
+#################### EnumBase ####################
+
+cdef extern from *:
+    object PyImport_Import(object)
+
+cdef object __Pyx_FlexibleEnumBase
+class __Pyx_FlexibleEnumBase(PyImport_Import("enum").IntEnum):
+    @classmethod
+    def _missing_(cls, value):
+        # This is a trimmed down version of "EnumFlag._missing_" with
+        # the flag-specific details removed.
+        pseudo_member = int.__new__(cls, value)
+        if not hasattr(pseudo_member, '_value_'):
+            pseudo_member._value_ = value
+        pseudo_member._name_ = None
+        # _value2member_map_ is an undocumented detail of enum so don't fail
+        # if we can't use it to cache pseudo-members
+        value2member_map = getattr(cls, '_value2member_map_', None)
+        if value2member_map is not None:
+            pseudo_member = value2member_map.setdefault(value, pseudo_member)
+        return pseudo_member
+
+    def __repr__(self):
+        if self._name_ is None:
+            # arbitrary value pseudo member
+            return f"<{self.__class__.__name__}: {self._value_!r}>"
+        return super().__repr__()
+
+
+#################### EnumType ####################
+# requires EnumBase but this is done manually to avoid duplication
+
+cdef extern from *:
+    object {{enum_to_pyint_func}}({{name}} value)
+
+
+# Create new IntFlag()-like enums:
+# the assumption is that C enums are sufficiently commonly
+# used as flags that this is the most appropriate base class.
+# On Python 3.15+ IntFlag doesn't accept negative numbers however.
+{{name}} = __Pyx_FlexibleEnumBase('{{name}}',  [
+    {{for item in items}}
+    ('{{item}}', {{enum_to_pyint_func}}({{item}})),
+    {{endfor}}
+    # Try to look up the module name dynamically if possible
+], module=globals().get("__module__", '{{static_modname}}'))
+
+{{if enum_doc is not None}}
+{{name}}.__doc__ = {{ repr(enum_doc) }}
+{{endif}}
+
+
+#################### CppScopedEnumBase ####################
+
+cdef object __Pyx_EnumBase
+from enum import IntEnum as __Pyx_EnumBase
+
+#################### CppScopedEnumType ####################
+# requires CppScopedEnumBase (but this is done manually to avoid duplication)
+cdef dict __Pyx_globals = globals()
+
+__Pyx_globals["{{name}}"] = __Pyx_EnumBase('{{name}}', [
+    {{for item in items}}
+    ('{{item}}', <{{underlying_type}}>({{name}}.{{item}})),
+    {{endfor}}
+], module=__Pyx_globals.get("__module__", '{{static_modname}}'))
+
+{{if enum_doc is not None}}
+__Pyx_globals["{{name}}"].__doc__ = {{ repr(enum_doc) }}
+{{endif}}
+
+
+#################### EnumTypeToPy ####################
+
+{{if module_name}}
+cdef object __pyx_imported_enum_{{funcname}} = None
+{{endif}}
+
+@cname("{{funcname}}")
+cdef {{funcname}}({{name}} c_val):
+    cdef object __pyx_enum
+{{if module_name}}
+    global __pyx_imported_enum_{{funcname}}
+    # There's a complication here: the Python enum wrapping is only generated
+    # for enums defined in the same module that they're used in. Therefore, if
+    # the enum was cimported from a different module, we try to import it.
+    # If that fails we return an int equivalent as the next best option.
+    if __pyx_imported_enum_{{funcname}} is None:
+        try:
+            from {{module_name}} import {{name}} as __pyx_imported_enum_{{funcname}}
+        except ImportError:
+            __pyx_imported_enum_{{funcname}} = False  # False indicates "don't try again"
+            import warnings
+            warnings.warn(
+                f"enum class {{name}} not importable from {{module_name}}. "
+                "You are probably using a cpdef enum declared in a .pxd file that "
+                "does not have a .py  or .pyx file.")
+    if __pyx_imported_enum_{{funcname}} is False:
+        # shortcut - if the import failed there's no point repeating it
+        # (and repeating the warning)
+        return <{{underlying_type}}>c_val
+    __pyx_enum = __pyx_imported_enum_{{funcname}}
+{{else}}
+    __pyx_enum = {{name}}
+{{endif}}
+    # TODO - Cython only manages to optimize C enums to a switch currently
+    if 0:
+        pass
+{{for item in items}}
+    elif c_val == {{name}}.{{item}}:
+        return __pyx_enum.{{item}}
+{{endfor}}
+    else:
+        underlying_c_val = <{{underlying_type}}>c_val
+{{if is_flag}}
+        return __pyx_enum(underlying_c_val)
+{{else}}
+        raise ValueError(f"{underlying_c_val} is not a valid {{name}}")
+{{endif}}

Cython/Utility/CppConvert.pyx

@@ -0,0 +1,282 @@
+# TODO: Figure out how many of the pass-by-value copies the compiler can eliminate.
+
+
+#################### string.from_py ####################
+
+cdef extern from *:
+    cdef cppclass string "{{type}}":
+        string() except +
+        string(char* c_str, size_t size) except +
+    cdef const char* __Pyx_PyObject_AsStringAndSize(object, Py_ssize_t*) except NULL
+
+@cname("{{cname}}")
+cdef string {{cname}}(object o) except *:
+    cdef Py_ssize_t length = 0
+    cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length)
+    return string(data, <size_t> length)
+
+
+#################### string.to_py ####################
+
+#cimport cython
+#from libcpp.string cimport string
+cdef extern from *:
+    const Py_ssize_t PY_SSIZE_T_MAX
+    cdef cppclass string "{{type}}":
+        char* data()
+        size_t size()
+
+{{for py_type in ['PyObject', 'PyUnicode', 'PyBytes', 'PyByteArray']}}
+cdef extern from *:
+    cdef object __Pyx_{{py_type}}_FromStringAndSize(const char*, size_t)
+
+@cname("{{cname.replace("PyObject", py_type, 1)}}")
+cdef inline object {{cname.replace("PyObject", py_type, 1)}}(const string& s):
+    if s.size() > <size_t> PY_SSIZE_T_MAX:
+        raise MemoryError()
+    return __Pyx_{{py_type}}_FromStringAndSize(s.data(), <Py_ssize_t> s.size())
+{{endfor}}
+
+
+#################### vector.from_py ####################
+#@requires: ObjectHandling.c::LengthHint
+
+cdef extern from *:
+    cdef cppclass vector "std::vector" [T]:
+        void push_back(T&) except +
+        void reserve(size_t) except +
+
+    cdef Py_ssize_t __Pyx_PyObject_LengthHint(object o, Py_ssize_t defaultval) except -1
+
+@cname("{{cname}}")
+cdef vector[X] {{cname}}(object o) except *:
+
+    cdef vector[X] v
+    cdef Py_ssize_t s = __Pyx_PyObject_LengthHint(o, 0)
+
+    if s > 0:
+        v.reserve(<size_t> s)
+
+    for item in o:
+        v.push_back(<X>item)
+
+    return v
+
+
+#################### vector.to_py ####################
+
+cdef extern from *:
+    cdef cppclass vector "std::vector" [T]:
+        size_t size()
+        T& operator[](size_t)
+
+cdef extern from "Python.h":
+    void Py_INCREF(object)
+    list PyList_New(Py_ssize_t size)
+    int __Pyx_PyList_SET_ITEM(object list, Py_ssize_t i, object o) except -1
+    const Py_ssize_t PY_SSIZE_T_MAX
+
+@cname("{{cname}}")
+cdef object {{cname}}(const vector[X]& v):
+    if v.size() > <size_t> PY_SSIZE_T_MAX:
+        raise MemoryError()
+    v_size_signed = <Py_ssize_t> v.size()
+
+    o = PyList_New(v_size_signed)
+
+    cdef Py_ssize_t i
+    cdef object item
+
+    for i in range(v_size_signed):
+        item = v[i]
+        Py_INCREF(item)
+        __Pyx_PyList_SET_ITEM(o, i, item)
+
+    return o
+
+#################### list.from_py ####################
+
+cdef extern from *:
+    cdef cppclass cpp_list "std::list" [T]:
+        void push_back(T&) except +
+
+@cname("{{cname}}")
+cdef cpp_list[X] {{cname}}(object o) except *:
+    cdef cpp_list[X] l
+    for item in o:
+        l.push_back(<X>item)
+    return l
+
+
+#################### list.to_py ####################
+
+cimport cython
+
+cdef extern from *:
+    cdef cppclass cpp_list "std::list" [T]:
+        cppclass const_iterator:
+            T& operator*()
+            const_iterator operator++()
+            bint operator!=(const_iterator)
+        const_iterator begin()
+        const_iterator end()
+        size_t size()
+
+cdef extern from "Python.h":
+    void Py_INCREF(object)
+    list PyList_New(Py_ssize_t size)
+    void __Pyx_PyList_SET_ITEM(object list, Py_ssize_t i, object o)
+    cdef Py_ssize_t PY_SSIZE_T_MAX
+
+@cname("{{cname}}")
+cdef object {{cname}}(const cpp_list[X]& v):
+    if v.size() > <size_t> PY_SSIZE_T_MAX:
+        raise MemoryError()
+
+    o = PyList_New(<Py_ssize_t> v.size())
+
+    cdef object item
+    cdef Py_ssize_t i = 0
+    cdef cpp_list[X].const_iterator iter = v.begin()
+
+    while iter != v.end():
+        item = cython.operator.dereference(iter)
+        Py_INCREF(item)
+        __Pyx_PyList_SET_ITEM(o, i, item)
+        cython.operator.preincrement(iter)
+        i += 1
+
+    return o
+
+
+#################### set.from_py ####################
+
+cdef extern from *:
+    cdef cppclass set "std::{{maybe_unordered}}set" [T]:
+        void insert(T&) except +
+
+@cname("{{cname}}")
+cdef set[X] {{cname}}(object o) except *:
+    cdef set[X] s
+    for item in o:
+        s.insert(<X>item)
+    return s
+
+
+#################### set.to_py ####################
+
+cimport cython
+
+cdef extern from *:
+    cdef cppclass cpp_set "std::{{maybe_unordered}}set" [T]:
+        cppclass const_iterator:
+            T& operator*()
+            const_iterator operator++()
+            bint operator!=(const_iterator)
+        const_iterator begin()
+        const_iterator end()
+
+@cname("{{cname}}")
+cdef object {{cname}}(const cpp_set[X]& s):
+    return {v for v in s}
+
+#################### pair.from_py ####################
+
+cdef extern from *:
+    cdef cppclass pair "std::pair" [T, U]:
+        pair() except +
+        pair(T&, U&) except +
+
+@cname("{{cname}}")
+cdef pair[X,Y] {{cname}}(object o) except *:
+    x, y = o
+    return pair[X,Y](<X>x, <Y>y)
+
+
+#################### pair.to_py ####################
+
+cdef extern from *:
+    cdef cppclass pair "std::pair" [T, U]:
+        T first
+        U second
+
+@cname("{{cname}}")
+cdef object {{cname}}(const pair[X,Y]& p):
+    return p.first, p.second
+
+
+#################### map.from_py ####################
+
+cdef extern from *:
+    cdef cppclass pair "std::pair" [T, U]:
+        pair(T&, U&) except +
+    cdef cppclass map "std::{{maybe_unordered}}map" [T, U]:
+        void insert(pair[T, U]&) except +
+    cdef cppclass vector "std::vector" [T]:
+        pass
+
+
+@cname("{{cname}}")
+cdef map[X,Y] {{cname}}(object o) except *:
+    cdef map[X,Y] m
+    for key, value in o.items():
+        m.insert(pair[X,Y](<X>key, <Y>value))
+    return m
+
+
+#################### map.to_py ####################
+# TODO: Work out const so that this can take a const
+# reference rather than pass by value.
+
+cimport cython
+
+cdef extern from *:
+    cdef cppclass map "std::{{maybe_unordered}}map" [T, U]:
+        cppclass value_type:
+            T first
+            U second
+        cppclass const_iterator:
+            value_type& operator*()
+            const_iterator operator++()
+            bint operator!=(const_iterator)
+        const_iterator begin()
+        const_iterator end()
+
+@cname("{{cname}}")
+cdef object {{cname}}(const map[X,Y]& s):
+    o = {}
+    cdef const map[X,Y].value_type *key_value
+    cdef map[X,Y].const_iterator iter = s.begin()
+    while iter != s.end():
+        key_value = &cython.operator.dereference(iter)
+        o[key_value.first] = key_value.second
+        cython.operator.preincrement(iter)
+    return o
+
+
+#################### complex.from_py ####################
+
+cdef extern from *:
+    cdef cppclass std_complex "std::complex" [T]:
+        std_complex()
+        std_complex(T, T) except +
+
+@cname("{{cname}}")
+cdef std_complex[X] {{cname}}(object o) except *:
+    cdef double complex z = o
+    return std_complex[X](<X>z.real, <X>z.imag)
+
+
+#################### complex.to_py ####################
+
+cdef extern from *:
+    cdef cppclass std_complex "std::complex" [T]:
+        X real()
+        X imag()
+
+@cname("{{cname}}")
+cdef object {{cname}}(const std_complex[X]& z):
+    cdef double complex tmp
+    tmp.real = <double>z.real()
+    tmp.imag = <double>z.imag()
+    return tmp

Cython/Utility/CppSupport.cpp

@@ -0,0 +1,151 @@
+/////////////// CppExceptionConversion.proto ///////////////
+
+#ifndef __Pyx_CppExn2PyErr
+#include <new>
+#include <typeinfo>
+#include <stdexcept>
+#include <ios>
+
+static void __Pyx_CppExn2PyErr() {
+  // Catch a handful of different errors here and turn them into the
+  // equivalent Python errors.
+  try {
+    if (PyErr_Occurred())
+      ; // let the latest Python exn pass through and ignore the current one
+    else
+      throw;
+  } catch (const std::bad_alloc& exn) {
+    PyErr_SetString(PyExc_MemoryError, exn.what());
+  } catch (const std::bad_cast& exn) {
+    PyErr_SetString(PyExc_TypeError, exn.what());
+  } catch (const std::bad_typeid& exn) {
+    PyErr_SetString(PyExc_TypeError, exn.what());
+  } catch (const std::domain_error& exn) {
+    PyErr_SetString(PyExc_ValueError, exn.what());
+  } catch (const std::invalid_argument& exn) {
+    PyErr_SetString(PyExc_ValueError, exn.what());
+  } catch (const std::ios_base::failure& exn) {
+    // Unfortunately, in standard C++ we have no way of distinguishing EOF
+    // from other errors here; be careful with the exception mask
+    PyErr_SetString(PyExc_IOError, exn.what());
+  } catch (const std::out_of_range& exn) {
+    // Change out_of_range to IndexError
+    PyErr_SetString(PyExc_IndexError, exn.what());
+  } catch (const std::overflow_error& exn) {
+    PyErr_SetString(PyExc_OverflowError, exn.what());
+  } catch (const std::range_error& exn) {
+    PyErr_SetString(PyExc_ArithmeticError, exn.what());
+  } catch (const std::underflow_error& exn) {
+    PyErr_SetString(PyExc_ArithmeticError, exn.what());
+  } catch (const std::exception& exn) {
+    PyErr_SetString(PyExc_RuntimeError, exn.what());
+  }
+  catch (...)
+  {
+    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
+  }
+}
+#endif
+
+/////////////// PythranConversion.proto ///////////////
+
+template <class T>
+auto __Pyx_pythran_to_python(T &&value) -> decltype(to_python(
+      typename pythonic::returnable<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::type{std::forward<T>(value)}))
+{
+  using returnable_type = typename pythonic::returnable<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::type;
+  return to_python(returnable_type{std::forward<T>(value)});
+}
+
+#define __Pyx_PythranShapeAccessor(x) (pythonic::builtins::getattr(pythonic::types::attr::SHAPE{}, x))
+
+////////////// MoveIfSupported.proto //////////////////
+
+#if CYTHON_USE_CPP_STD_MOVE
+  #include <utility>
+  #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x)
+#else
+  #define __PYX_STD_MOVE_IF_SUPPORTED(x) x
+#endif
+
+////////////// EnumClassDecl.proto //////////////////
+//@proto_block: utility_code_proto_before_types
+
+#if defined (_MSC_VER)
+  #if _MSC_VER >= 1910
+    #define __PYX_ENUM_CLASS_DECL enum
+  #else
+    #define __PYX_ENUM_CLASS_DECL
+  #endif
+#else
+  #define __PYX_ENUM_CLASS_DECL enum
+#endif
+
+////////////// OptionalLocals.proto ////////////////
+//@proto_block: utility_code_proto_before_types
+
+#include <utility>
+#if defined(CYTHON_USE_BOOST_OPTIONAL)
+    // fallback mode - std::optional is preferred but this gives
+    // people with a less up-to-date compiler a chance
+    #include <boost/optional.hpp>
+    #define __Pyx_Optional_BaseType boost::optional
+#else
+    #include <optional>
+    // since std::optional is a C++17 features, a templated using declaration should be safe
+    // (although it could be replaced with a define)
+    template <typename T>
+    using __Pyx_Optional_BaseType = std::optional<T>;
+#endif
+
+// This class reuses as much of the implementation of std::optional as possible.
+// The only place it differs significantly is the assignment operators, which use
+// "emplace" (thus requiring move/copy constructors, but not move/copy
+// assignment operators). This is preferred because it lets us work with assignable
+// types (for example those with const members)
+template <typename T>
+class __Pyx_Optional_Type : private __Pyx_Optional_BaseType<T> {
+public:
+    using __Pyx_Optional_BaseType<T>::__Pyx_Optional_BaseType;
+    using __Pyx_Optional_BaseType<T>::has_value;
+    using __Pyx_Optional_BaseType<T>::operator*;
+    using __Pyx_Optional_BaseType<T>::operator->;
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)
+    __Pyx_Optional_Type(const __Pyx_Optional_Type& rhs)
+        : __Pyx_Optional_BaseType<T>(rhs)
+    {}
+
+    __Pyx_Optional_Type(__Pyx_Optional_Type&& rhs)
+        : __Pyx_Optional_BaseType<T>(std::move(rhs))
+    {}
+
+    __Pyx_Optional_Type& operator=(const __Pyx_Optional_Type& rhs) {
+        this->emplace(*rhs);
+        return *this;
+    }
+    __Pyx_Optional_Type& operator=(__Pyx_Optional_Type&& rhs) {
+        this->emplace(std::move(*rhs));
+        return *this;
+    }
+    template <typename U=T>
+    __Pyx_Optional_Type& operator=(U&& rhs) {
+        this->emplace(std::forward<U>(rhs));
+        return *this;
+    }
+#else
+    // Note - the "cpp_locals" feature is designed to require C++14.
+    // This pre-c++11 fallback is largely untested, and definitely won't work
+    // in all the cases that the more modern version does
+    using __Pyx_Optional_BaseType<T>::operator=; // the chances are emplace can't work...
+#endif
+};
+
+//////////////////////// DefaultPlacementNew.proto ///////////////////////
+
+#include <new>
+
+// avoid having to know the name of the class being constructed (e.g. when user is accessing through a typedef)
+template<typename T>
+void __Pyx_default_placement_construct(T* x) {
+    new (static_cast<void*>(x)) T();
+}