Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersTuples.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /* These helpers are used to work with tuples.
 
 */
@@ -26,25 +11,34 @@
 #endif
 
 #if NUITKA_TUPLE_HAS_FREELIST
-static struct _Py_tuple_state *_Nuitka_Py_get_tuple_state(void) {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    return &interp->tuple;
-}
 
-PyObject *MAKE_TUPLE_EMPTY(Py_ssize_t size) {
+PyObject *MAKE_TUPLE_EMPTY(PyThreadState *tstate, Py_ssize_t size) {
     PyTupleObject *result_tuple;
 
     // Lets not get called other than this
     assert(size > 0);
 
-    struct _Py_tuple_state *state = _Nuitka_Py_get_tuple_state();
+    // This is the CPython name, spell-checker: ignore numfree
+#if PYTHON_VERSION < 0x3d0
+    PyTupleObject **items = tstate->interp->tuple.free_list;
+    int *numfree = tstate->interp->tuple.numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_tuple_freelist *state = &freelists->tuples;
+    PyTupleObject **items = state->items;
+    int *numfree = state->numfree;
+#endif
 
-    if ((size < PyTuple_MAXSAVESIZE) && (result_tuple = state->free_list[size]) != NULL) {
-        state->free_list[size] = (PyTupleObject *)result_tuple->ob_item[0];
-        state->numfree[size] -= 1;
+#if PYTHON_VERSION < 0x3b0
+    Py_ssize_t index = size;
+#else
+    Py_ssize_t index = size - 1;
+#endif
+
+    if ((size < PyTuple_MAXSAVESIZE) && (result_tuple = items[index]) != NULL) {
+        items[index] = (PyTupleObject *)result_tuple->ob_item[0];
+        numfree[index] -= 1;
 
-        // TODO: At least 3.11.0 corrupted this.
-        Py_SET_SIZE(result_tuple, size);
         assert(Py_SIZE(result_tuple) == size);
         assert(Py_TYPE(result_tuple) == &PyTuple_Type);
 
@@ -70,26 +64,29 @@ PyObject *MAKE_TUPLE_EMPTY(Py_ssize_t size) {
 
     Nuitka_GC_Track(result_tuple);
 
+    assert(PyTuple_CheckExact(result_tuple));
+    assert(PyTuple_GET_SIZE(result_tuple) == size);
+
     return (PyObject *)result_tuple;
 }
 
-PyObject *MAKE_TUPLE_EMPTY_VAR(Py_ssize_t size) {
+PyObject *MAKE_TUPLE_EMPTY_VAR(PyThreadState *tstate, Py_ssize_t size) {
     if (size == 0) {
         PyObject *result = const_tuple_empty;
         Py_INCREF(result);
         return result;
     } else {
-        return MAKE_TUPLE_EMPTY(size);
+        return MAKE_TUPLE_EMPTY(tstate, size);
     }
 }
 
 #endif
 
-PyObject *TUPLE_CONCAT(PyObject *tuple1, PyObject *tuple2) {
+PyObject *TUPLE_CONCAT(PyThreadState *tstate, PyObject *tuple1, PyObject *tuple2) {
     Py_ssize_t size = Py_SIZE(tuple1) + Py_SIZE(tuple2);
 
     // Do not ignore MemoryError, may actually happen.
-    PyTupleObject *result = (PyTupleObject *)MAKE_TUPLE_EMPTY_VAR(size);
+    PyTupleObject *result = (PyTupleObject *)MAKE_TUPLE_EMPTY_VAR(tstate, size);
     if (unlikely(result == NULL)) {
         return NULL;
     }
@@ -115,12 +112,12 @@ PyObject *TUPLE_CONCAT(PyObject *tuple1, PyObject *tuple2) {
     return (PyObject *)result;
 }
 
-PyObject *TUPLE_COPY(PyObject *tuple) {
+PyObject *TUPLE_COPY(PyThreadState *tstate, PyObject *tuple) {
     CHECK_OBJECT(tuple);
     assert(PyTuple_CheckExact(tuple));
 
     Py_ssize_t size = PyTuple_GET_SIZE(tuple);
-    PyObject *result = MAKE_TUPLE_EMPTY(size);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -134,3 +131,18 @@ PyObject *TUPLE_COPY(PyObject *tuple) {
 
     return result;
 }
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/static_src/HelpersTypes.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 // This file is included from another C file, help IDEs to still parse it on
 // its own.
 #ifdef __IDE_ONLY__
@@ -48,8 +33,15 @@ bool Nuitka_Type_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
 
         return false;
     } else {
-        // Fallback for uninitialized classes to API usage
-        return PyType_IsSubtype(a, b) != 0;
+        // Fallback for uninitialized classes to base class scan
+        do {
+            if (a == b) {
+                return true;
+            }
+            a = a->tp_base;
+        } while (a != NULL);
+
+        return (b == &PyBaseObject_Type);
     }
 }
 
@@ -143,9 +135,9 @@ getattrofunc PyObject_GenericGetAttr_resolved;
 setattrofunc PyObject_GenericSetAttr_resolved;
 
 // Our wrapper for "PyType_Ready" that takes care of trying to avoid DLL entry
-// points for generic attributes.
+// points for generic attributes. spell-checker: ignore aiter
 void Nuitka_PyType_Ready(PyTypeObject *type, PyTypeObject *base, bool generic_get_attr, bool generic_set_attr,
-                         bool self_iter, bool await_self_iter, bool self_aiter) {
+                         bool self_iter, bool await_self_iter, bool await_self_aiter) {
     assert(type->tp_base == NULL);
 
     PyObject_GenericGetAttr_resolved = PyBaseObject_Type.tp_getattro;
@@ -174,15 +166,164 @@ void Nuitka_PyType_Ready(PyTypeObject *type, PyTypeObject *base, bool generic_ge
         type->tp_as_async->am_await = PyObject_SelfIter;
     }
 
-    if (self_aiter) {
+    if (await_self_aiter) {
         assert(type->tp_as_async->am_aiter == NULL);
         type->tp_as_async->am_aiter = PyObject_SelfIter;
     }
 #else
     assert(!await_self_iter);
-    assert(!self_aiter);
+    assert(!await_self_aiter);
 #endif
 
-    int res = PyType_Ready(type);
+#if PYTHON_VERSION >= 0x3a0
+    type->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+
+    NUITKA_MAY_BE_UNUSED int res = PyType_Ready(type);
     assert(res >= 0);
-}
+}
+
+#if PYTHON_VERSION >= 0x3c0
+
+typedef struct {
+    PyObject_HEAD PyObject *name;
+    PyObject *type_params;
+    PyObject *compute_value;
+    PyObject *value;
+    PyObject *module;
+} typealiasobject;
+
+static PyTypeObject *getTypeAliasType(void) {
+    static PyTypeObject *type_alias_type = NULL;
+
+    if (type_alias_type == NULL) {
+
+        PyObject *typing_module = PyImport_ImportModule("_typing");
+        CHECK_OBJECT(typing_module);
+
+        type_alias_type = (PyTypeObject *)PyObject_GetAttrString(typing_module, "TypeAliasType");
+        CHECK_OBJECT(type_alias_type);
+    }
+
+    return type_alias_type;
+}
+
+PyObject *MAKE_TYPE_ALIAS(PyObject *name, PyObject *type_params, PyObject *compute_value) {
+    // TODO: For Python 3.13 we can use the intrinsic.
+
+    typealiasobject *ta = Nuitka_GC_New(getTypeAliasType());
+
+    // TODO: Lets follow Python new inline function in the future, this is 3.12
+    // only code, so we can use it here.
+    ta->name = Py_NewRef(name);
+    ta->type_params = Py_IsNone(type_params) ? NULL : Py_XNewRef(type_params);
+    ta->compute_value = Py_XNewRef(compute_value);
+    ta->value = NULL;
+    ta->module = NULL;
+
+    Nuitka_GC_Track(ta);
+
+    return (PyObject *)ta;
+}
+
+typedef struct {
+    PyObject_HEAD PyObject *name;
+    PyObject *bound;
+    PyObject *evaluate_bound;
+    PyObject *constraints;
+    PyObject *evaluate_constraints;
+    bool covariant;
+    bool contravariant;
+    bool infer_variance;
+} typevarobject;
+
+static typevarobject *_Nuitka_typevar_alloc(PyThreadState *tstate, PyObject *name, PyObject *bound,
+                                            PyObject *evaluate_bound, PyObject *constraints,
+                                            PyObject *evaluate_constraints, bool covariant, bool contravariant,
+                                            bool infer_variance, PyObject *module) {
+    PyTypeObject *tp = tstate->interp->cached_objects.typevar_type;
+    typevarobject *result = Nuitka_GC_New(tp);
+
+    result->name = Py_NewRef(name);
+
+    result->bound = Py_XNewRef(bound);
+    result->evaluate_bound = Py_XNewRef(evaluate_bound);
+    result->constraints = Py_XNewRef(constraints);
+    result->evaluate_constraints = Py_XNewRef(evaluate_constraints);
+
+    result->covariant = covariant;
+    result->contravariant = contravariant;
+    result->infer_variance = infer_variance;
+
+    Nuitka_GC_Track(result);
+
+    // TODO: Not seen yet.
+    if (unlikely(module != NULL)) {
+        if (PyObject_SetAttrString((PyObject *)result, "__module__", module) < 0) {
+            Py_DECREF(result);
+            return NULL;
+        }
+    }
+
+    return result;
+}
+
+PyObject *MAKE_TYPE_VAR(PyThreadState *tstate, PyObject *name) {
+    // TODO: For Python 3.13 this would work.
+    // return _PyIntrinsics_UnaryFunctions[INTRINSIC_TYPEVAR].func(tstate, name);
+
+    return (PyObject *)_Nuitka_typevar_alloc(tstate, name, NULL, NULL, NULL, NULL, false, false, true, NULL);
+}
+
+static PyTypeObject *_getTypeGenericAliasType(void) {
+    static PyTypeObject *type_generic_alias_type = NULL;
+
+    if (type_generic_alias_type == NULL) {
+
+        PyObject *typing_module = PyImport_ImportModule("_typing");
+        CHECK_OBJECT(typing_module);
+
+        type_generic_alias_type = (PyTypeObject *)PyObject_GetAttrString(typing_module, "_GenericAlias");
+        CHECK_OBJECT(type_generic_alias_type);
+    }
+
+    return type_generic_alias_type;
+}
+
+static PyObject *_Nuitka_unpack_typevartuples(PyObject *params) {
+    assert(PyTuple_Check(params));
+
+    // TODO: Not implemented yet.
+
+    return Py_NewRef(params);
+}
+
+PyObject *MAKE_TYPE_GENERIC(PyThreadState *tstate, PyObject *params) {
+    CHECK_OBJECT(params);
+    PyObject *unpacked_params = _Nuitka_unpack_typevartuples(params);
+    CHECK_OBJECT(unpacked_params);
+
+    PyObject *args[2] = {(PyObject *)tstate->interp->cached_objects.generic_type, unpacked_params};
+
+    PyObject *called = (PyObject *)_getTypeGenericAliasType();
+
+    PyObject *result = CALL_FUNCTION_WITH_ARGS2(tstate, called, args);
+    Py_DECREF(unpacked_params);
+    return result;
+}
+
+#endif
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/static_src/InspectPatcher.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /**
  * This is responsible for updating parts of CPython to better work with Nuitka
  * by replacing CPython implementations with enhanced versions.
@@ -44,6 +29,8 @@ static PyObject *_inspect_getgeneratorstate_replacement(PyObject *self, PyObject
         return NULL;
     }
 
+    CHECK_OBJECT(object);
+
     if (Nuitka_Generator_Check(object)) {
         struct Nuitka_GeneratorObject *generator = (struct Nuitka_GeneratorObject *)object;
 
@@ -127,6 +114,64 @@ static PyMethodDef _method_def_types_coroutine_replacement = {"coroutine", (PyCF
 
 #endif
 
+#if PYTHON_VERSION >= 0x3c0
+
+static char *kw_list_depth[] = {(char *)"depth", NULL};
+
+static bool Nuitka_FrameIsCompiled(_PyInterpreterFrame *frame) {
+    return ((frame->frame_obj != NULL) && Nuitka_Frame_Check((PyObject *)frame->frame_obj));
+}
+
+static bool Nuitka_FrameIsIncomplete(_PyInterpreterFrame *frame) {
+    bool r = _PyFrame_IsIncomplete(frame);
+
+    return r;
+}
+
+static PyObject *orig_sys_getframemodulename = NULL;
+
+static PyObject *_sys_getframemodulename_replacement(PyObject *self, PyObject *args, PyObject *kwds) {
+    PyObject *depth_arg = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:_getframemodulename", kw_list_depth, &depth_arg)) {
+        return NULL;
+    }
+
+    PyObject *index_value = Nuitka_Number_IndexAsLong(depth_arg ? depth_arg : const_int_0);
+
+    if (unlikely(index_value == NULL)) {
+        return NULL;
+    }
+
+    Py_ssize_t depth_ssize = PyLong_AsSsize_t(index_value);
+
+    Py_DECREF(index_value);
+
+    PyThreadState *tstate = _PyThreadState_GET();
+
+    _PyInterpreterFrame *frame = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
+    while ((frame != NULL) && ((Nuitka_FrameIsIncomplete(frame)) || depth_ssize-- > 0)) {
+        frame = frame->previous;
+    }
+
+    if ((frame != NULL) && (Nuitka_FrameIsCompiled(frame))) {
+        PyObject *frame_globals = PyObject_GetAttrString((PyObject *)frame->frame_obj, "f_globals");
+
+        PyObject *result = LOOKUP_ATTRIBUTE(tstate, frame_globals, const_str_plain___name__);
+        Py_DECREF(frame_globals);
+
+        return result;
+    }
+
+    return CALL_FUNCTION_WITH_SINGLE_ARG(tstate, orig_sys_getframemodulename, depth_arg);
+}
+
+// spell-checker: ignore getframemodulename
+static PyMethodDef _method_def_sys_getframemodulename_replacement = {
+    "getcoroutinestate", (PyCFunction)_sys_getframemodulename_replacement, METH_VARARGS | METH_KEYWORDS, NULL};
+
+#endif
+
 /* Replace inspect functions with ones that handle compiles types too. */
 void patchInspectModule(PyThreadState *tstate) {
     static bool is_done = false;
@@ -164,13 +209,11 @@ void patchInspectModule(PyThreadState *tstate) {
     old_getgeneratorstate = PyObject_GetAttrString(module_inspect, "getgeneratorstate");
     CHECK_OBJECT(old_getgeneratorstate);
 
-    if (PyFunction_Check(old_getgeneratorstate)) {
-        PyObject *inspect_getgeneratorstate_replacement =
-            PyCFunction_New(&_method_def_inspect_getgeneratorstate_replacement, NULL);
-        CHECK_OBJECT(inspect_getgeneratorstate_replacement);
+    PyObject *inspect_getgeneratorstate_replacement =
+        PyCFunction_New(&_method_def_inspect_getgeneratorstate_replacement, NULL);
+    CHECK_OBJECT(inspect_getgeneratorstate_replacement);
 
-        PyObject_SetAttrString(module_inspect, "getgeneratorstate", inspect_getgeneratorstate_replacement);
-    }
+    PyObject_SetAttrString(module_inspect, "getgeneratorstate", inspect_getgeneratorstate_replacement);
 
 #if PYTHON_VERSION >= 0x350
     // Patch "inspect.getcoroutinestate" unless it is already patched.
@@ -215,22 +258,45 @@ class GeneratorWrapperEnhanced(_old_GeneratorWrapper):\n\
             if gen.gi_code.co_flags & 0x0020:\n\
                 self._GeneratorWrapper__isgen = True\n\
 \n\
-types._GeneratorWrapper = GeneratorWrapperEnhanced\
-";
+types._GeneratorWrapper = GeneratorWrapperEnhanced\n"
+#if PYTHON_VERSION >= 0x3b0
+                                                  "\
+import inspect\n\
+_old_get_code_position = inspect._get_code_position\n\
+def _get_code_position(code, instruction_index):\n\
+    try:\n\
+        return _old_get_code_position(code, instruction_index)\n\
+    except StopIteration:\n\
+        return None, None, None, None\n\
+inspect._get_code_position=_get_code_position\n\
+"
+#endif
+        ;
 
     PyObject *wrapper_enhancement_code_object = Py_CompileString(wrapper_enhancement_code, "<exec>", Py_file_input);
     CHECK_OBJECT(wrapper_enhancement_code_object);
 
     {
-        PyObject *module = PyImport_ExecCodeModule("nuitka_types_patch", wrapper_enhancement_code_object);
+        NUITKA_MAY_BE_UNUSED PyObject *module =
+            PyImport_ExecCodeModule("nuitka_types_patch", wrapper_enhancement_code_object);
         CHECK_OBJECT(module);
 
-        bool bool_res = Nuitka_DelModuleString(tstate, "nuitka_types_patch");
+        NUITKA_MAY_BE_UNUSED bool bool_res = Nuitka_DelModuleString(tstate, "nuitka_types_patch");
         assert(bool_res != false);
     }
 
 #endif
 
+#endif
+
+#if PYTHON_VERSION >= 0x3c0
+    orig_sys_getframemodulename = Nuitka_SysGetObject("_getframemodulename");
+
+    PyObject *sys_getframemodulename_replacement =
+        PyCFunction_New(&_method_def_sys_getframemodulename_replacement, NULL);
+    CHECK_OBJECT(sys_getframemodulename_replacement);
+
+    Nuitka_SysSetObject("_getframemodulename", sys_getframemodulename_replacement);
 #endif
 
     is_done = true;
@@ -352,3 +418,18 @@ static void Nuitka_tb_dealloc(PyTracebackObject *tb) {
 }
 
 void patchTracebackDealloc(void) { PyTraceBack_Type.tp_dealloc = (destructor)Nuitka_tb_dealloc; }
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.