Cython 3.2.0__cp39-abi3-win32.whl

Cython/Utility/Dataclasses.c

@@ -0,0 +1,101 @@
+//////////////////// LoadDataclassesModule.proto /////////////////////
+
+static PyObject *__Pyx_Load_dataclasses_Module(void);
+
+//////////////////// LoadDataclassesModule /////////////////////
+
+static PyObject *__Pyx_Load_dataclasses_Module(void) {
+    return PyImport_Import(PYIDENT("dataclasses"));
+}
+
+//////////////////// DataclassesCallHelper.proto ////////////////////////
+
+static PyObject* __Pyx_DataclassesCallHelper(PyObject *callable, PyObject *kwds); /* proto */
+
+//////////////////// DataclassesCallHelper ////////////////////////
+
+// The signature of a few of the dataclasses module functions has
+// been expanded over the years. Cython always passes the full set
+// of arguments from the most recent version we know of, so needs
+// to remove any arguments that don't exist on earlier versions.
+
+static int __Pyx_DataclassesCallHelper_FilterToDict(PyObject *callable, PyObject *kwds, PyObject *new_kwds, PyObject *args_list, int is_kwonly) {
+    Py_ssize_t size, i;
+    size = PySequence_Size(args_list);
+    if (unlikely(size < 0)) return -1;
+
+    for (i=0; i<size; ++i) {
+        PyObject *key, *value;
+        int setitem_result;
+        key = PySequence_GetItem(args_list, i);
+        if (!key) return -1;
+
+        if (PyUnicode_Check(key) && (
+                PyUnicode_CompareWithASCIIString(key, "self") == 0 ||
+                // namedtuple constructor in fallback code
+                PyUnicode_CompareWithASCIIString(key, "_cls") == 0)) {
+            Py_DECREF(key);
+            continue;
+        }
+
+        value = PyDict_GetItem(kwds, key);
+        if (!value) {
+            if (is_kwonly) {
+                Py_DECREF(key);
+                continue;
+            } else {
+                // The most likely reason for this is that Cython
+                // hasn't kept up to date with the Python dataclasses module.
+                // To be nice to our users, try not to fail, but ask them
+                // to report a bug so we can keep up to date.
+                value = Py_None;
+                if (PyErr_WarnFormat(
+                        PyExc_RuntimeWarning, 1,
+                        "Argument %S not passed to %R. This is likely a bug in Cython so please report it.",
+                        key, callable) == -1) {
+                    Py_DECREF(key);
+                    return -1;
+                }
+            }
+        }
+        Py_INCREF(value);
+        setitem_result = PyDict_SetItem(new_kwds, key, value);
+        Py_DECREF(key);
+        Py_DECREF(value);
+        if (setitem_result == -1) return -1;
+    }
+    return 0;
+}
+
+static PyObject* __Pyx_DataclassesCallHelper(PyObject *callable, PyObject *kwds) {
+    PyObject *new_kwds=NULL, *result=NULL;
+    PyObject *inspect;
+    PyObject *args_list=NULL, *kwonly_args_list=NULL, *getfullargspec_result=NULL;
+
+    // Going via inspect to work out what arguments to pass is unlikely to be the
+    // fastest thing ever. However, it is compatible, and only happens once
+    // at module-import time.
+    inspect = PyImport_ImportModule("inspect");
+    if (!inspect) goto bad;
+    getfullargspec_result = PyObject_CallMethodObjArgs(inspect, PYUNICODE("getfullargspec"), callable, NULL);
+    Py_DECREF(inspect);
+    if (!getfullargspec_result) goto bad;
+    args_list = PyObject_GetAttrString(getfullargspec_result, "args");
+    if (!args_list) goto bad;
+    kwonly_args_list = PyObject_GetAttrString(getfullargspec_result, "kwonlyargs");
+    if (!kwonly_args_list) goto bad;
+
+    new_kwds = PyDict_New();
+    if (!new_kwds) goto bad;
+
+    // copy over only those arguments that are in the specification
+    if (__Pyx_DataclassesCallHelper_FilterToDict(callable, kwds, new_kwds, args_list, 0) == -1) goto bad;
+    if (__Pyx_DataclassesCallHelper_FilterToDict(callable, kwds, new_kwds, kwonly_args_list, 1) == -1) goto bad;
+    result = PyObject_Call(callable, EMPTY(tuple), new_kwds);
+bad:
+    Py_XDECREF(getfullargspec_result);
+    Py_XDECREF(args_list);
+    Py_XDECREF(kwonly_args_list);
+    Py_XDECREF(new_kwds);
+    return result;
+}

Cython/Utility/Embed.c

@@ -0,0 +1,121 @@
+//////////////////// MainFunction ////////////////////
+
+#ifdef __FreeBSD__
+#include <floatingpoint.h>
+#endif
+
+
+{{for mname in embed_modules}}
+    __Pyx_PyMODINIT_FUNC PyInit_{{mname}}(void) CYTHON_SMALL_CODE; /*proto*/
+{{endfor}}
+
+#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
+int {{wmain_method}}(int argc, wchar_t **argv)
+#else
+static int __Pyx_main(int argc, wchar_t **argv)
+#endif
+{
+    /* 754 requires that FP exceptions run in "no stop" mode by default,
+     * and until C vendors implement C99's ways to control FP exceptions,
+     * Python requires non-stop mode.  Alas, some platforms enable FP
+     * exceptions by default.  Here we disable them.
+     */
+#ifdef __FreeBSD__
+    fp_except_t m;
+
+    m = fpgetmask();
+    fpsetmask(m & ~FP_X_OFL);
+#endif
+
+    {{for mname in (module_name,) + embed_modules}}
+    if (PyImport_AppendInittab("{{mname}}", PyInit_{{mname}}) < 0) return 1;
+    {{endfor}}
+
+    {
+        PyStatus status;
+        PyConfig config;
+        PyConfig_InitPythonConfig(&config);
+        // Disable parsing command line arguments
+        config.parse_argv = 0;
+
+        if (argc && argv) {
+            status = PyConfig_SetString(&config, &config.program_name, argv[0]);
+            if (PyStatus_Exception(status)) {
+                PyConfig_Clear(&config);
+                return 1;
+            }
+
+            status = PyConfig_SetArgv(&config, argc, argv);
+            if (PyStatus_Exception(status)) {
+                PyConfig_Clear(&config);
+                return 1;
+            }
+        }
+
+        status = Py_InitializeFromConfig(&config);
+        if (PyStatus_Exception(status)) {
+            PyConfig_Clear(&config);
+            return 1;
+        }
+
+        PyConfig_Clear(&config);
+    }
+
+    { /* init module '{{module_name}}' as '__main__' */
+      PyObject* m = NULL;
+      {{module_is_main}} = 1;
+      m = PyImport_ImportModule("{{module_name}}");
+
+      if (!m && PyErr_Occurred()) {
+          PyErr_Print(); /* This exits with the right code if SystemExit. */
+          return 1;
+      }
+      Py_XDECREF(m);
+    }
+    if (Py_FinalizeEx() < 0)
+        return 2;
+    return 0;
+}
+
+
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
+#include <locale.h>
+
+int
+{{main_method}}(int argc, char **argv)
+{
+    if (!argc) {
+        return __Pyx_main(0, NULL);
+    }
+    else {
+        int i, res;
+        wchar_t **argv_copy = (wchar_t **)malloc(sizeof(wchar_t*)*argc);
+        /* We need a second copy, as Python might modify the first one. */
+        wchar_t **argv_copy2 = (wchar_t **)malloc(sizeof(wchar_t*)*argc);
+        char *oldloc = strdup(setlocale(LC_ALL, NULL));
+        if (!argv_copy || !argv_copy2 || !oldloc) {
+            fprintf(stderr, "out of memory\\n");
+            free(argv_copy);
+            free(argv_copy2);
+            free(oldloc);
+            return 1;
+        }
+        res = 0;
+        setlocale(LC_ALL, "");
+        for (i = 0; i < argc; i++) {
+            argv_copy2[i] = argv_copy[i] = Py_DecodeLocale(argv[i], NULL);
+            if (!argv_copy[i]) res = 1;  /* failure, but continue to simplify cleanup */
+        }
+        setlocale(LC_ALL, oldloc);
+        free(oldloc);
+        if (res == 0)
+            res = __Pyx_main(argc, argv_copy);
+        for (i = 0; i < argc; i++) {
+            PyMem_RawFree(argv_copy2[i]);
+        }
+        free(argv_copy);
+        free(argv_copy2);
+        return res;
+    }
+}
+#endif