Cython 3.1.0__py3-none-any.whl

Cython/Utility/Dataclasses.c

@@ -0,0 +1,185 @@
+///////////////////// ModuleLoader.proto //////////////////////////
+
+static PyObject* __Pyx_LoadInternalModule(const char* name, const char* fallback_code); /* proto */
+
+//////////////////// ModuleLoader ///////////////////////
+//@requires: CommonStructures.c::FetchSharedCythonModule
+
+static PyObject* __Pyx_LoadInternalModule(const char* name, const char* fallback_code) {
+    // We want to be able to use the contents of the standard library dataclasses module where available.
+    // If those objects aren't available (due to Python version) then a simple fallback is substituted
+    // instead, which largely just fails with a not-implemented error.
+    //
+    // The fallbacks are placed in the "shared abi module" as a convenient internal place to
+    // store them
+
+    PyObject *shared_abi_module = 0, *module = 0;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+    PyObject *result;
+#endif
+
+    shared_abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!shared_abi_module) return NULL;
+
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+     if (PyObject_GetOptionalAttrString(shared_abi_module, name, &result) != 0) {
+        Py_DECREF(shared_abi_module);
+        return result;
+     }
+#else
+    if (PyObject_HasAttrString(shared_abi_module, name)) {
+        PyObject* result = PyObject_GetAttrString(shared_abi_module, name);
+        Py_DECREF(shared_abi_module);
+        return result;
+    }
+#endif
+
+    // the best and simplest case is simply to defer to the standard library (if available)
+    module = PyImport_ImportModule(name);
+    if (!module) {
+        PyObject *localDict, *runValue, *builtins, *modulename;
+        if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad;
+        PyErr_Clear();  /* this is reasonably likely (especially on older versions of Python) */
+        modulename = PyUnicode_FromFormat("_cython_" CYTHON_ABI ".%s", name);
+        if (!modulename) goto bad;
+#if CYTHON_COMPILING_IN_CPYTHON
+        module = PyImport_AddModuleObject(modulename);  /* borrowed */
+#else
+        module = PyImport_AddModule(PyBytes_AsString(modulename));  /* borrowed */
+#endif
+        Py_DECREF(modulename);
+        if (!module) goto bad;
+        Py_INCREF(module);
+        if (PyObject_SetAttrString(shared_abi_module, name, module) < 0) goto bad;
+        localDict = PyModule_GetDict(module);  /* borrowed */
+        if (!localDict) goto bad;
+        builtins = PyEval_GetBuiltins();  /* borrowed */
+        if (!builtins) goto bad;
+        if (PyDict_SetItemString(localDict, "__builtins__", builtins) <0) goto bad;
+
+#if CYTHON_COMPILING_IN_LIMITED_API
+        {
+            PyObject *compiled = Py_CompileString(fallback_code, "<dataclass fallback code>", Py_file_input);
+            if (!compiled) goto bad;
+            runValue = PyEval_EvalCode(compiled, localDict, localDict);
+            Py_DECREF(compiled);
+        }
+#else
+        runValue = PyRun_String(fallback_code, Py_file_input, localDict, localDict);
+#endif
+        if (!runValue) goto bad;
+        Py_DECREF(runValue);
+    }
+    goto shared_cleanup;
+
+    bad:
+        Py_CLEAR(module);
+    shared_cleanup:
+        Py_XDECREF(shared_abi_module);
+    return module;
+}
+
+///////////////////// SpecificModuleLoader.proto //////////////////////
+//@substitute: tempita
+
+static PyObject* __Pyx_Load_{{cname}}_Module(void); /* proto */
+
+
+//////////////////// SpecificModuleLoader ///////////////////////
+//@requires: ModuleLoader
+
+static PyObject* __Pyx_Load_{{cname}}_Module(void) {
+    return __Pyx_LoadInternalModule("{{cname}}", {{py_code}});
+}
+
+//////////////////// 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/Dataclasses.py

@@ -0,0 +1,112 @@
+################### Dataclasses_fallback ###############################
+
+# This is the fallback dataclass code if the stdlib module isn't available.
+# It defines enough of the support types to be used with cdef classes
+# and to fail if used on regular types.
+
+# (Intended to be included as py code - not compiled)
+
+from collections import namedtuple
+try:
+    from types import MappingProxyType
+except ImportError:
+    # mutable fallback if unavailable
+    MappingProxyType = lambda x: x
+
+class _MISSING_TYPE:
+    pass
+MISSING = _MISSING_TYPE()
+
+_DataclassParams = namedtuple('_DataclassParams',
+    ["init", "repr", "eq", "order", "unsafe_hash", "frozen",
+     "match_args", "kw_only", "slots", "weakref_slot"])
+class Field:
+    __slots__ = ('name',
+                 'type',
+                 'default',
+                 'default_factory',
+                 'repr',
+                 'hash',
+                 'init',
+                 'compare',
+                 'metadata',
+                 'kw_only',
+                 '_field_type',  # Private: not to be used by user code.
+                 )
+
+    def __init__(self, default, default_factory, init, repr, hash, compare,
+                 metadata, kw_only):
+        self.name = None
+        self.type = None
+        self.default = default
+        self.default_factory = default_factory
+        self.init = init
+        self.repr = repr
+        self.hash = hash
+        self.compare = compare
+        # Be aware that if MappingProxyType is unavailable (i.e. py2?) then we
+        # don't enforce non-mutability that the real module does
+        self.metadata = (MappingProxyType({})
+                         if metadata is None else
+                         MappingProxyType(metadata))
+        self.kw_only = kw_only
+        self._field_type = None
+
+    def __repr__(self):
+        return ('Field('
+                'name={!r},'
+                'type={!r},'
+                'default={!r},'
+                'default_factory={!r},'
+                'init={!r},'
+                'repr={!r},'
+                'hash={!r},'
+                'compare={!r},'
+                'metadata={!r},'
+                'kwonly={!r},'
+                ')'.format(self.name, self.type, self.default,
+                           self.default_factory, self.init,
+                           self.repr, self.hash, self.compare,
+                           self.metadata, self.kw_only))
+
+# A sentinel object for default values to signal that a default
+# factory will be used.  This is given a nice repr() which will appear
+# in the function signature of dataclasses' constructors.
+class _HAS_DEFAULT_FACTORY_CLASS:
+    def __repr__(self):
+        return '<factory>'
+_HAS_DEFAULT_FACTORY = _HAS_DEFAULT_FACTORY_CLASS()
+
+def dataclass(*args, **kwds):
+    raise NotImplementedError("Standard library 'dataclasses' module"
+        "is unavailable, likely due to the version of Python you're using.")
+
+# Markers for the various kinds of fields and pseudo-fields.
+class _FIELD_BASE:
+    def __init__(self, name):
+        self.name = name
+    def __repr__(self):
+        return self.name
+_FIELD = _FIELD_BASE('_FIELD')
+_FIELD_CLASSVAR = _FIELD_BASE('_FIELD_CLASSVAR')
+_FIELD_INITVAR = _FIELD_BASE('_FIELD_INITVAR')
+
+def field(*ignore, **kwds):
+    default = kwds.pop("default", MISSING)
+    default_factory = kwds.pop("default_factory", MISSING)
+    init = kwds.pop("init", True)
+    repr = kwds.pop("repr", True)
+    hash = kwds.pop("hash", None)
+    compare = kwds.pop("compare", True)
+    metadata = kwds.pop("metadata", None)
+    kw_only = kwds.pop("kw_only", None)
+
+    if kwds:
+        raise ValueError("field received unexpected keyword arguments: %s"
+                         % list(kwds.keys()))
+    if default is not MISSING and default_factory is not MISSING:
+        raise ValueError('cannot specify both default and default_factory')
+    if ignore:
+        raise ValueError("'field' does not take any positional arguments")
+    return Field(default, default_factory, init,
+                 repr, hash, compare, metadata, kw_only)

Cython/Utility/Embed.c

@@ -0,0 +1,125 @@
+//////////////////// MainFunction ////////////////////
+
+#ifdef __FreeBSD__
+#include <floatingpoint.h>
+#endif
+
+#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
+int %(wmain_method)s(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
+#if PY_VERSION_HEX < 0x03080000
+    if (argc && argv)
+        Py_SetProgramName(argv[0]);
+#endif
+
+    if (PyImport_AppendInittab("%(module_name)s", PyInit_%(module_name)s) < 0) return 1;
+
+#if PY_VERSION_HEX < 0x03080000
+    Py_Initialize();
+    if (argc && argv)
+        PySys_SetArgv(argc, argv);
+#else
+    {
+        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);
+    }
+#endif
+
+    { /* init module '%(module_name)s' as '__main__' */
+      PyObject* m = NULL;
+      %(module_is_main)s = 1;
+      m = PyImport_ImportModule("%(module_name)s");
+
+      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)s(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