Nuitka-winsvc 2.1.6__cp311-cp311-win_amd64.whl → 2.2.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersTypes.c

@@ -171,6 +171,48 @@ void Nuitka_PyType_Ready(PyTypeObject *type, PyTypeObject *base, bool generic_ge
     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) {
+    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;
+}
+#endif
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and
 //     integrates with CPython, but also works on its own.
 //

nuitka/build/static_src/MainProgram.c

@@ -191,7 +191,7 @@ extern void _initCompiledFrameType();
 static wchar_t **convertCommandLineParameters(int argc, char **argv) {
     // Originally taken from CPython3: There seems to be no sane way to use
     static wchar_t **argv_copy;
-    argv_copy = (wchar_t **)PyMem_MALLOC(sizeof(wchar_t *) * argc);
+    argv_copy = (wchar_t **)malloc(sizeof(wchar_t *) * argc);
 
     // Temporarily disable locale for conversions to not use it.
     char *old_locale = strdup(setlocale(LC_ALL, NULL));

nuitka/build/static_src/MetaPathBasedLoader.c

@@ -200,8 +200,9 @@ static PyObject *loadModuleFromCodeObject(PyObject *module, PyCodeObject *code_o
     if (is_package) {
         /* Set __path__ properly, unlike frozen module importer does. */
         PyObject *path_list = MAKE_LIST_EMPTY(1);
-        if (unlikely(path_list == NULL))
+        if (unlikely(path_list == NULL)) {
             return NULL;
+        }
 
         int res = PyList_SetItem(path_list, 0, module_path_entry);
         if (unlikely(res != 0)) {

nuitka/build/static_src/OnefileBootstrap.c

@@ -65,8 +65,8 @@
 #define _NUITKA_ONEFILE_CHILD_GRACE_TIME_INT 5000
 #define _NUITKA_ONEFILE_TEMP_SPEC "{TEMP}/onefile_{PID}_{TIME}"
 
-#define _NUITKA_EXPERIMENTAL_DEBUG_AUTO_UPDATE
 #define _NUITKA_AUTO_UPDATE_BOOL 1
+#define _NUITKA_AUTO_UPDATE_DEBUG_BOOL 1
 #define _NUITKA_AUTO_UPDATE_URL_SPEC "https://..."
 
 #endif
@@ -1019,7 +1019,7 @@ int main(int argc, char **argv) {
     signal(SIGTERM, ourConsoleCtrlHandler);
 #endif
 
-#ifdef _NUITKA_AUTO_UPDATE_BOOL
+#if _NUITKA_AUTO_UPDATE_BOOL
     checkAutoUpdates();
 #endif
 
@@ -1213,7 +1213,7 @@ int main(int argc, char **argv) {
 
     closePayloadData();
 
-#ifdef _NUITKA_AUTO_UPDATE_BOOL
+#if _NUITKA_AUTO_UPDATE_BOOL
     exe_file_updatable = true;
 #endif
 

nuitka/code_generation/BinaryOperationHelperDefinitions.py

@@ -200,9 +200,11 @@ def _makeNumberOps(op_code, include_nbool, in_place):
         _makeFriendOps(op_code, include_nbool, in_place, "INT", "LONG", "FLOAT"),
         # Special operations, currently used with constant values mostly.
         _makeFriendOps(op_code, include_nbool, in_place, "INT", "CLONG"),
-        _makeFriendOps(op_code, include_nbool, in_place, "LONG", "DIGIT")
-        if op_code in ("ADD", "SUB")  # TODO: Add more
-        else (),
+        (
+            _makeFriendOps(op_code, include_nbool, in_place, "LONG", "DIGIT")
+            if op_code in ("ADD", "SUB")  # TODO: Add more
+            else ()
+        ),
         _makeFriendOps(op_code, include_nbool, in_place, "FLOAT", "CFLOAT"),
     )
 

nuitka/code_generation/BuiltinCodes.py

@@ -6,6 +6,7 @@
 This is code generation for built-in references, and some built-ins like range,
 bin, etc.
 """
+
 from nuitka import Builtins
 from nuitka.PythonVersions import python_version
 

nuitka/code_generation/CodeGeneration.py

@@ -253,6 +253,7 @@ from .ModuleCodes import (
     generateNuitkaLoaderCreationCode,
     getModuleCode,
 )
+from .NetworkxCodes import generateNetworkxUtilsDecoratorsArgmapCallCode
 from .OperationCodes import (
     generateOperationBinaryCode,
     generateOperationNotCode,
@@ -341,8 +342,10 @@ from .SubscriptCodes import (
     generateSubscriptCheckCode,
     generateSubscriptLookupCode,
 )
+from .TensorflowCodes import generateTensorflowFunctionCallCode
 from .TryCodes import generateTryCode
 from .TupleCodes import generateBuiltinTupleCode, generateTupleCreationCode
+from .TypeAliasCodes import generateTypeAliasCode
 from .VariableCodes import (
     generateAssignmentVariableCode,
     generateDelVariableCode,
@@ -667,6 +670,7 @@ addExpressionDispatchDict(
         "EXPRESSION_BUILTIN_XRANGE3": generateBuiltinXrange3Code,
         "EXPRESSION_BUILTIN_MAKE_EXCEPTION": generateBuiltinMakeExceptionCode,
         "EXPRESSION_BUILTIN_MAKE_EXCEPTION_IMPORT_ERROR": generateBuiltinMakeExceptionCode,
+        "EXPRESSION_BUILTIN_MAKE_EXCEPTION_MODULE_NOT_FOUND_ERROR": generateBuiltinMakeExceptionCode,
         "EXPRESSION_BUILTIN_REF": generateBuiltinRefCode,
         "EXPRESSION_BUILTIN_WITH_CONTEXT_REF": generateBuiltinRefCode,
         "EXPRESSION_BUILTIN_EXCEPTION_REF": generateExceptionRefCode,
@@ -939,10 +943,17 @@ addExpressionDispatchDict(
         "EXPRESSION_OS_PATH_ISABS_CALL": generateOsPathIsabsCallCode,
         "EXPRESSION_OS_LISTDIR_CALL": generateOsListdirCallCode,
         "EXPRESSION_MATCH_ARGS": generateMatchArgsCode,
+        "EXPRESSION_TYPE_ALIAS": generateTypeAliasCode,
         "EXPRESSION_STR_OPERATION_FORMAT": generateStrFormatMethodCode,
         # TODO: Should have all of these generically or not. This one is required for now.
         "EXPRESSION_DICT_OPERATION_FROMKEYS_REF": generateDictOperationFromkeysRefCode,
         "EXPRESSION_TYPE_OPERATION_PREPARE": generateTypeOperationPrepareCode,
+        # PyPI module "tensorflow" specific stuff
+        "EXPRESSION_TENSORFLOW_FUNCTION_REF": generateImportModuleNameHardCode,
+        "EXPRESSION_TENSORFLOW_FUNCTION_CALL": generateTensorflowFunctionCallCode,
+        # PyPI module "networkx" specific stuff
+        "EXPRESSION_NETWORKX_UTILS_DECORATORS_ARGMAP_REF": generateImportModuleNameHardCode,
+        "EXPRESSION_NETWORKX_UTILS_DECORATORS_ARGMAP_CALL": generateNetworkxUtilsDecoratorsArgmapCallCode,
     }
 )
 

nuitka/code_generation/CodeHelpers.py

@@ -48,9 +48,11 @@ def generateExpressionCode(to_name, expression, emit, context, allow_none=False)
             "Problem with %r at %s"
             % (
                 expression,
-                ""
-                if expression is None
-                else expression.getSourceReference().getAsString(),
+                (
+                    ""
+                    if expression is None
+                    else expression.getSourceReference().getAsString()
+                ),
             )
         )
         raise

nuitka/code_generation/CodeObjectCodes.py

@@ -70,12 +70,16 @@ def _getMakeCodeObjectArgs(code_object_handle, context):
         " | ".join(co_flags) or "0",
         context.getConstantCode(constant=code_object_handle.co_name),
         context.getConstantCode(constant=code_object_handle.co_qualname),
-        context.getConstantCode(constant=code_object_handle.co_varnames)
-        if code_object_handle.co_varnames
-        else "NULL",
-        context.getConstantCode(constant=code_object_handle.co_freevars)
-        if code_object_handle.co_freevars
-        else "NULL",
+        (
+            context.getConstantCode(constant=code_object_handle.co_varnames)
+            if code_object_handle.co_varnames
+            else "NULL"
+        ),
+        (
+            context.getConstantCode(constant=code_object_handle.co_freevars)
+            if code_object_handle.co_freevars
+            else "NULL"
+        ),
         code_object_handle.co_argcount,
         code_object_handle.co_kwonlyargcount,
         code_object_handle.co_posonlyargcount,

nuitka/code_generation/ComparisonCodes.py

@@ -7,7 +7,11 @@ Rich comparisons, "in", and "not in", also "is", and "is not", and the
 "isinstance" check as used in conditions, as well as exception matching.
 """
 
-from nuitka.nodes.shapes.BuiltinTypeShapes import tshape_bool
+from nuitka.nodes.shapes.BuiltinTypeShapes import (
+    tshape_bool,
+    tshape_frozenset,
+    tshape_set,
+)
 from nuitka.nodes.shapes.StandardShapes import tshape_unknown
 from nuitka.PythonOperators import (
     comparison_inversions,
@@ -279,9 +283,21 @@ def generateComparisonExpressionCode(to_name, expression, emit, context):
 
         res_name = context.getIntResName()
 
+        right_shape = right.getTypeShape()
+
+        if right_shape in (tshape_set, tshape_frozenset):
+            c_api = "PySet_Contains"
+        else:
+            c_api = "PySequence_Contains"
+
         emit(
-            "%s = PySequence_Contains(%s, %s);"
-            % (res_name, right_name, left_name)  # sequence goes first in the API.
+            "%s = %s(%s, %s);"
+            % (
+                res_name,
+                c_api,
+                right_name,
+                left_name,
+            )  # sequence goes first in the API.
         )
 
         getErrorExitBoolCode(

nuitka/code_generation/ConstantCodes.py

@@ -17,8 +17,10 @@ import os
 import sys
 
 from nuitka import Options
+from nuitka.ModuleRegistry import getRootTopModule
 from nuitka.PythonVersions import python_version
 from nuitka.Serialization import ConstantAccessor
+from nuitka.utils.CStrings import encodePythonStringToC
 from nuitka.utils.Distributions import getDistributionTopLevelPackageNames
 from nuitka.Version import getNuitkaVersionTuple
 
@@ -143,6 +145,9 @@ def getConstantsDefinitionCode():
     major, minor, micro, is_final, _rc_number = getNuitkaVersionTuple()
 
     body = template_constants_reading % {
+        "module_name_cstr": encodePythonStringToC(
+            getRootTopModule().getFullName().asString().encode("utf8")
+        ),
         "global_constants_count": constant_accessor.getConstantsCount(),
         "sys_executable": sys_executable,
         "sys_prefix": sys_prefix,

nuitka/code_generation/Contexts.py

@@ -215,12 +215,12 @@ class TempMixin(object):
             else:
                 preserver_obj_init = None
 
-            self.preserver_variable_declaration[
-                preserver_id
-            ] = self.variable_storage.addVariableDeclarationTop(
-                "struct Nuitka_ExceptionStackItem",
-                "exception_preserved_%d" % preserver_id,
-                preserver_obj_init,
+            self.preserver_variable_declaration[preserver_id] = (
+                self.variable_storage.addVariableDeclarationTop(
+                    "struct Nuitka_ExceptionStackItem",
+                    "exception_preserved_%d" % preserver_id,
+                    preserver_obj_init,
+                )
             )
 
         return self.preserver_variable_declaration[preserver_id]
@@ -365,6 +365,10 @@ class PythonContextBase(getMetaClassBase("Context", require_slots=True)):
     def getConstantCode(self, constant, deep_check=False):
         pass
 
+    @abstractmethod
+    def addModuleInitCode(self, code):
+        pass
+
     @abstractmethod
     def getModuleCodeName(self):
         pass
@@ -527,6 +531,9 @@ class PythonChildContextBase(PythonContextBase):
     def getConstantCode(self, constant, deep_check=False):
         return self.parent.getConstantCode(constant, deep_check=deep_check)
 
+    def addModuleInitCode(self, code):
+        self.parent.addModuleInitCode(code)
+
     def getModuleCodeName(self):
         return self.parent.getModuleCodeName()
 
@@ -764,6 +771,7 @@ class PythonModuleContext(
         "variable_storage",
         "function_table_entries",
         "constant_accessor",
+        "module_init_codes",
         # FrameDeclarationsMixin
         "frame_variables_stack",
         "frame_type_descriptions",
@@ -820,6 +828,8 @@ class PythonModuleContext(
             top_level_name="mod_consts", data_filename=data_filename
         )
 
+        self.module_init_codes = []
+
     def __repr__(self):
         return "<PythonModuleContext instance for module %s>" % self.name
 
@@ -879,6 +889,12 @@ class PythonModuleContext(
     def getConstantsCount(self):
         return self.constant_accessor.getConstantsCount()
 
+    def getModuleInitCodes(self):
+        return self.module_init_codes
+
+    def addModuleInitCode(self, code):
+        self.module_init_codes.append(code)
+
     def addFunctionCreationInfo(self, creation_info):
         self.function_table_entries.append(creation_info)
 

nuitka/code_generation/Emission.py

@@ -8,6 +8,7 @@ this is to collect them, providing the emit implementation. Sometimes nested
 use of these will occur.
 
 """
+
 import contextlib
 
 from .Indentation import indented

nuitka/code_generation/ErrorCodes.py

@@ -247,44 +247,36 @@ def getLocalVariableReferenceErrorCode(variable, condition, emit, context):
 
 # TODO: Get rid of this function entirely.
 def getNameReferenceErrorCode(variable_name, condition, emit, context):
-    helper_code = "FORMAT_NAME_ERROR"
+    helper_code = "RAISE_CURRENT_EXCEPTION_NAME_ERROR"
 
     if python_version < 0x340:
         owner = context.getOwner()
 
         if not owner.isCompiledPythonModule() and not owner.isExpressionClassBodyBase():
-            helper_code = "FORMAT_GLOBAL_NAME_ERROR"
+            helper_code = "RAISE_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR"
 
     (
         exception_type,
         exception_value,
-        _exception_tb,
+        exception_tb,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
-    set_exception = "%s(&%s, &%s, %s);" % (
-        helper_code,
-        exception_type,
-        exception_value,
-        context.getConstantCode(variable_name),
-    )
-
-    # TODO: Make this part of the helper code as well.
-    if python_version >= 0x300:
-        set_exception = [set_exception]
-        set_exception.extend(_getExceptionChainingCode(context))
-
     emit(
         template_error_format_name_error_exception
         % {
             "condition": condition,
             "exception_exit": context.getExceptionEscape(),
-            "set_exception": indented(set_exception),
+            "raise_name_error_helper": helper_code,
+            "variable_name": context.getConstantCode(variable_name),
             "release_temps": indented(getErrorExitReleaseCode(context)),
             "var_description_code": indented(
                 getFrameVariableTypeDescriptionCode(context)
             ),
             "line_number_code": indented(getErrorLineNumberUpdateCode(context)),
+            "exception_type": exception_type,
+            "exception_value": exception_value,
+            "exception_tb": exception_tb,
         }
     )
 

nuitka/code_generation/EvalCodes.py

@@ -254,9 +254,11 @@ def generateExecCode(statement, emit, context):
     # Default filename with origin in improved mode.
     filename_name.getCType().emitAssignmentCodeFromConstant(
         to_name=filename_name,
-        constant="<string>"
-        if Options.is_full_compat
-        else "<string at %s>" % source_ref.getAsString(),
+        constant=(
+            "<string>"
+            if Options.is_full_compat
+            else "<string at %s>" % source_ref.getAsString()
+        ),
         may_escape=False,
         emit=emit,
         context=context,

nuitka/code_generation/ExceptionCodes.py

@@ -193,7 +193,14 @@ def generateBuiltinMakeExceptionCode(to_name, expression, emit, context):
                 context=context,
             )
 
-        if expression.getExceptionName() == "ImportError" and python_version >= 0x300:
+        if exception_type == "ImportError" and python_version >= 0x300:
+            is_new_import_error = True
+        elif exception_type == "ModuleNotFoundError" and python_version >= 0x360:
+            is_new_import_error = True
+        else:
+            is_new_import_error = False
+
+        if is_new_import_error:
             from .PythonAPICodes import getReferenceExportCode
 
             import_error_name_expression = expression.subnode_name

nuitka/code_generation/ExpressionCTypeSelectionHelpers.py

@@ -7,6 +7,7 @@ This is first used for comparisons and binary operations, but should see
 general use too and expand beyond constant values, e.g. covering constant
 values that are of behind conditions or variables.
 """
+
 from nuitka.nodes.shapes.BuiltinTypeShapes import (
     tshape_bytearray,
     tshape_bytes,

nuitka/code_generation/FrameCodes.py

@@ -244,9 +244,11 @@ def getFrameGuardHeavyCode(
                 "locals_size": getFrameLocalsStorageSize(
                     context.getFrameVariableTypeDescriptions()
                 ),
-                "locals_dict_name": frame_node.getLocalsScope().getCodeName()
-                if use_locals_dict
-                else "NULL",
+                "locals_dict_name": (
+                    frame_node.getLocalsScope().getCodeName()
+                    if use_locals_dict
+                    else "NULL"
+                ),
             }
         )
 

nuitka/code_generation/FunctionCodes.py

@@ -5,7 +5,6 @@
 
 """
 
-
 from nuitka.PythonVersions import python_version
 from nuitka.Tracing import general
 

nuitka/code_generation/GeneratorCodes.py

@@ -101,9 +101,9 @@ def getGeneratorObjectCode(
 
     if needs_generator_return:
         generator_exit += template_generator_return_exit % {
-            "return_value": context.getReturnValueName()
-            if python_version >= 0x300
-            else None,
+            "return_value": (
+                context.getReturnValueName() if python_version >= 0x300 else None
+            ),
             "function_cleanup": indented(function_cleanup),
         }
 

nuitka/code_generation/GlobalConstants.py

@@ -91,8 +91,6 @@ def getConstantDefaultPopulation():
         # Meta path based loader.
         "read",
         "rb",
-        # List methods
-        "remove",
         # File handling
         "/",
         "\\",

nuitka/code_generation/ImportCodes.py

@@ -230,6 +230,8 @@ def getImportHardModuleGetterCode(module_name, context):
 def getImportModuleNameHardCode(
     to_name, module_name, import_name, needs_check, emit, context
 ):
+    module_name = ModuleName(module_name)
+
     if module_name == "sys":
         emit("""%s = Nuitka_SysGetObject("%s");""" % (to_name, import_name))
         needs_release = False

nuitka/code_generation/JitCodes.py

@@ -0,0 +1,44 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Code generation for JIT specific stuff, preserving source code for runtime. """
+
+from nuitka.Options import isStandaloneMode
+
+
+def addUncompiledFunctionSourceDict(func_value, context):
+    if (
+        isStandaloneMode()
+        and func_value is not None
+        and func_value.isExpressionFunctionCreation()
+    ):
+        function_ref = func_value.subnode_function_ref
+
+        function_super_qualified_name = function_ref.getFunctionSuperQualifiedName()
+        function_source_code = function_ref.getFunctionSourceCode()
+
+        context.addModuleInitCode(
+            """\
+SET_UNCOMPILED_FUNCTION_SOURCE_DICT(%s, %s);
+"""
+            % (
+                context.getConstantCode(function_super_qualified_name),
+                context.getConstantCode(function_source_code),
+            )
+        )
+
+
+#     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/code_generation/ListCodes.py

@@ -414,25 +414,19 @@ def generateListOperationRemoveCode(to_name, expression, emit, context):
         expression=expression, emit=emit, context=context
     )
 
-    with withObjectCodeTemporaryAssignment(
-        to_name, "list_remove_result", expression, emit, context
-    ) as result_name:
-        # TODO: Have a dedicated list helper instead, this could be more efficient,
-        # this call is also very bad.
-        emit("assert(PyList_CheckExact(%s));" % list_arg_name)
-        emit(
-            "%s = PyObject_CallMethodObjArgs(%s, const_str_plain_remove, %s, NULL);"
-            % (result_name, list_arg_name, value_arg_name)
-        )
+    res_name = context.getBoolResName()
 
-        getErrorExitCode(
-            check_name=result_name,
-            release_names=(list_arg_name, value_arg_name),
-            emit=emit,
-            context=context,
-        )
+    emit("%s = LIST_REMOVE(%s, %s);" % (res_name, list_arg_name, value_arg_name))
 
-        context.addCleanupTempName(result_name)
+    getErrorExitBoolCode(
+        condition="%s == false" % res_name,
+        release_names=(list_arg_name, value_arg_name),
+        needs_check=expression.mayRaiseExceptionOperation(),
+        emit=emit,
+        context=context,
+    )
+
+    assignConstantNoneResult(to_name, emit, context)
 
 
 def generateListOperationSort1Code(to_name, expression, emit, context):

nuitka/code_generation/MatchCodes.py

@@ -5,7 +5,6 @@
 
 """
 
-
 from .CodeHelpers import (
     generateChildExpressionsCode,
     withObjectCodeTemporaryAssignment,

nuitka/code_generation/ModuleCodes.py

@@ -131,7 +131,8 @@ def getModuleCode(
         "module_functions_code": function_body_codes,
         "module_function_table_entries": indented(function_table_entries_decl),
         "temps_decl": indented(local_var_inits),
-        "module_code": indented(module_codes.codes),
+        "module_init_codes": indented(context.getModuleInitCodes()),
+        "module_codes": indented(module_codes.codes),
         "module_exit": module_exit,
         "module_code_objects_decl": indented(module_code_objects_decl, 0),
         "module_code_objects_init": indented(module_code_objects_init, 1),

nuitka/code_generation/Namify.py

@@ -9,7 +9,6 @@ it is really necessary.
 
 """
 
-
 import math
 import re
 import sys