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

nuitka/code_generation/NetworkxCodes.py

@@ -0,0 +1,51 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Code generation for networkx module specific stuff. """
+
+from .BuiltinCodes import getBuiltinCallViaSpecCode
+from .ImportCodes import getImportModuleNameHardCode
+from .JitCodes import addUncompiledFunctionSourceDict
+
+
+def generateNetworkxUtilsDecoratorsArgmapCallCode(to_name, expression, emit, context):
+    """This is for networkx.utils.decorators.argmap calls."""
+
+    # TODO: Have global cached forms of hard attribute lookup results too.
+    argmap_class_name = context.allocateTempName("argmap_class", unique=True)
+
+    getImportModuleNameHardCode(
+        to_name=argmap_class_name,
+        module_name="networkx.utils.decorators",
+        import_name="argmap",
+        needs_check=False,
+        emit=emit,
+        context=context,
+    )
+
+    addUncompiledFunctionSourceDict(func_value=expression.subnode_func, context=context)
+
+    getBuiltinCallViaSpecCode(
+        spec=expression.spec,
+        called_name=argmap_class_name,
+        to_name=to_name,
+        expression=expression,
+        emit=emit,
+        context=context,
+    )
+
+
+#     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/OperationCodes.py

@@ -104,12 +104,14 @@ def _getBinaryOperationCode(
     ) = decideExpressionCTypes(
         left=left,
         right=right,
-        may_swap_arguments="never"
-        if inplace
-        else (
-            "number"
-            if operator in ("Add", "Mult", "BitOr", "BitAnd", "BitXor")
-            else "never"
+        may_swap_arguments=(
+            "never"
+            if inplace
+            else (
+                "number"
+                if operator in ("Add", "Mult", "BitOr", "BitAnd", "BitXor")
+                else "never"
+            )
         ),
     )
 

nuitka/code_generation/PackageResourceCodes.py

@@ -520,11 +520,13 @@ def generatePkgResourcesIterEntryPointsCallCode(to_name, expression, emit, conte
             called_name=iter_entry_points_function_name,
             expression=expression,
             arg_names=(
-                group_arg_name,
-                name_arg_name,
-            )
-            if name_arg_name is not None
-            else (group_arg_name,),
+                (
+                    group_arg_name,
+                    name_arg_name,
+                )
+                if name_arg_name is not None
+                else (group_arg_name,)
+            ),
             emit=emit,
             context=context,
         )

nuitka/code_generation/TensorflowCodes.py

@@ -0,0 +1,54 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Code generation for tensorflow module specific stuff. """
+
+from .BuiltinCodes import getBuiltinCallViaSpecCode
+from .ImportCodes import getImportModuleNameHardCode
+from .JitCodes import addUncompiledFunctionSourceDict
+
+
+def generateTensorflowFunctionCallCode(to_name, expression, emit, context):
+    """This is for tensorflow.function calls."""
+
+    # TODO: Have global cached forms of hard attribute lookup results too.
+    tensorflow_function_name = context.allocateTempName(
+        "tensorflow_function", unique=True
+    )
+
+    getImportModuleNameHardCode(
+        to_name=tensorflow_function_name,
+        module_name="tensorflow",
+        import_name="function",
+        needs_check=False,
+        emit=emit,
+        context=context,
+    )
+
+    # Include source code of "tensorflow.function" decorated functions.
+    addUncompiledFunctionSourceDict(func_value=expression.subnode_func, context=context)
+
+    getBuiltinCallViaSpecCode(
+        spec=expression.spec,
+        called_name=tensorflow_function_name,
+        to_name=to_name,
+        expression=expression,
+        emit=emit,
+        context=context,
+    )
+
+
+#     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/TypeAliasCodes.py

@@ -0,0 +1,71 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Code generation for type alias statement helpers.
+
+"""
+
+from .CodeHelpers import (
+    generateChildExpressionCode,
+    withObjectCodeTemporaryAssignment,
+)
+from .ErrorCodes import getErrorExitCode
+from .TupleCodes import getTupleCreationCode
+
+
+def generateTypeAliasCode(to_name, expression, emit, context):
+    type_params_name = context.allocateTempName("type_params_value")
+    getTupleCreationCode(
+        to_name=type_params_name,
+        elements=expression.subnode_type_params,
+        emit=emit,
+        context=context,
+    )
+
+    compute_value_name = generateChildExpressionCode(
+        expression=expression.subnode_compute_value, emit=emit, context=context
+    )
+
+    assert (
+        expression.getParent().isStatementAssignmentVariable()
+    ), expression.getParent()
+    type_alias_name = expression.getParent().getVariableName()
+
+    with withObjectCodeTemporaryAssignment(
+        to_name, "type_alias_value", expression, emit, context
+    ) as value_name:
+        emit(
+            "%s = MAKE_TYPE_ALIAS(%s, %s, %s);"
+            % (
+                value_name,
+                context.getConstantCode(constant=type_alias_name),
+                type_params_name,
+                compute_value_name,
+            )
+        )
+
+        getErrorExitCode(
+            check_name=value_name,
+            release_names=(type_alias_name, compute_value_name),
+            emit=emit,
+            context=context,
+            needs_check=expression.mayRaiseExceptionOperation(),
+        )
+
+        context.addCleanupTempName(value_name)
+
+
+#     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/VariableCodes.py

@@ -110,11 +110,13 @@ if (unlikely(%(value_name)s == NULL)) {
 }
 """
                 % {
-                    "helper_code": "GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION"
-                    if python_version < 0x340
-                    and not owner.isCompiledPythonModule()
-                    and not owner.isExpressionClassBodyBase()
-                    else "GET_MODULE_VARIABLE_VALUE_FALLBACK",
+                    "helper_code": (
+                        "GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION"
+                        if python_version < 0x340
+                        and not owner.isCompiledPythonModule()
+                        and not owner.isExpressionClassBodyBase()
+                        else "GET_MODULE_VARIABLE_VALUE_FALLBACK"
+                    ),
                     "module_identifier": context.getModuleCodeName(),
                     "value_name": value_name,
                     "var_name": context.getConstantCode(constant=variable.getName()),

nuitka/code_generation/VariableDeclarations.py

@@ -5,6 +5,7 @@
 Holds the information necessary to make C code declarations related to a variable.
 
 """
+
 from contextlib import contextmanager
 
 from .c_types.CTypeBooleans import CTypeBool

nuitka/code_generation/c_types/CTypeCLongs.py

@@ -5,7 +5,6 @@
 
 """
 
-
 from .CTypeBases import CTypeBase
 
 

nuitka/code_generation/c_types/CTypeNuitkaInts.py

@@ -5,7 +5,6 @@
 
 """
 
-
 from nuitka.code_generation.templates.CodeTemplatesVariables import (
     template_release_object_clear,
     template_release_object_unclear,

nuitka/code_generation/c_types/CTypeVoids.py

@@ -4,6 +4,7 @@
 """ CType classes for C void, this cannot represent unassigned, nor indicate exception.
 
 """
+
 from nuitka.code_generation.ErrorCodes import getReleaseCode
 
 from .CTypeBases import CTypeBase, CTypeNotReferenceCountedMixin

nuitka/code_generation/templates/CodeTemplatesConstants.py

@@ -127,6 +127,7 @@ static void _createGlobalConstants(PyThreadState *tstate) {
         {(char *)"no_docstrings", (char *)"boolean indicating --python-flag=no_docstrings usage"},
         {(char *)"no_annotations", (char *)"boolean indicating --python-flag=no_annotations usage"},
         {(char *)"module", (char *)"boolean indicating --module usage"},
+        {(char *)"main", (char *)"name of main module at runtime"},
         {0}
     };
 
@@ -149,6 +150,7 @@ static void _createGlobalConstants(PyThreadState *tstate) {
     PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 3, Nuitka_String_FromString("%(nuitka_version_level)s"));
 
     PyObject *binary_directory = getContainingDirectoryObject(false);
+    binary_directory = OS_PATH_ABSPATH(tstate, binary_directory);
 #ifdef _NUITKA_STANDALONE
 #ifndef _NUITKA_ONEFILE_MODE
     binary_directory = STRIP_DIRNAME(binary_directory);
@@ -210,6 +212,19 @@ static void _createGlobalConstants(PyThreadState *tstate) {
 #endif
     PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 11, is_module_mode);
 
+#ifdef _NUITKA_MODULE
+    PyObject *main_name;
+
+    if (_Py_PackageContext != NULL) {
+        main_name = Nuitka_String_FromString(_Py_PackageContext);
+    } else {
+        main_name = Nuitka_String_FromString(%(module_name_cstr)s);
+    }
+#else
+    PyObject *main_name = Nuitka_String_FromString("__main__");
+#endif
+    PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 12, main_name);
+
     // Prevent users from creating the Nuitka version type object.
     Nuitka_VersionInfoType.tp_init = NULL;
     Nuitka_VersionInfoType.tp_new = NULL;

nuitka/code_generation/templates/CodeTemplatesExceptions.py

@@ -56,7 +56,7 @@ if (%(condition)s) {
 template_error_format_name_error_exception = """\
 if (unlikely(%(condition)s)) {
 %(release_temps)s
-%(set_exception)s
+%(raise_name_error_helper)s(tstate, %(variable_name)s, &%(exception_type)s, &%(exception_value)s);
 
 %(line_number_code)s
 %(var_description_code)s

nuitka/code_generation/templates/CodeTemplatesIterators.py

@@ -5,7 +5,6 @@
 
 """
 
-
 template_iterator_check = """\
 // Check if iterator has left-over elements.
 CHECK_OBJECT(%(iterator_name)s); assert(HAS_ITERNEXT(%(iterator_name)s));

nuitka/code_generation/templates/CodeTemplatesLoader.py

@@ -5,7 +5,6 @@
 
 """
 
-
 template_metapath_loader_compiled_module_entry = """\
 {%(module_name)s, modulecode_%(module_identifier)s, 0, 0, %(flags)s
 #if defined(_NUITKA_FREEZER_HAS_FILE_PATH)

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -451,8 +451,11 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
     // Temp variables if any
 %(temps_decl)s
 
+    // Module init code if any
+%(module_init_codes)s
+
     // Module code.
-%(module_code)s
+%(module_codes)s
 
     // Report to PGO about leaving the module without error.
     PGO_onModuleExit("%(module_identifier)s", false);

nuitka/code_generation/templates/CodeTemplatesVariables.py

@@ -45,7 +45,7 @@ template_write_local_inplace = """\
 """
 
 template_write_shared_inplace = """\
-PyCell_SET(%(identifier)s, %(tmp_name)s);
+Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
 """
 
 
@@ -62,7 +62,7 @@ template_write_local_clear_ref1 = """\
 template_write_shared_unclear_ref0 = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, %(tmp_name)s);
+    Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
     Py_XDECREF(old);
 }
 """
@@ -70,7 +70,7 @@ template_write_shared_unclear_ref0 = """\
 template_write_shared_unclear_ref1 = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, %(tmp_name)s);
+    Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
     Py_INCREF(%(tmp_name)s);
     Py_XDECREF(old);
 }
@@ -78,13 +78,13 @@ template_write_shared_unclear_ref1 = """\
 
 template_write_shared_clear_ref0 = """\
 assert(Nuitka_Cell_GET(%(identifier)s) == NULL);
-PyCell_SET(%(identifier)s, %(tmp_name)s);
+Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
 """
 
 template_write_shared_clear_ref1 = """\
 assert(Nuitka_Cell_GET(%(identifier)s) == NULL);
 Py_INCREF(%(tmp_name)s);
-PyCell_SET(%(identifier)s, %(tmp_name)s);
+Nuitka_Cell_SET(%(identifier)s, %(tmp_name)s);
 """
 
 
@@ -96,7 +96,7 @@ Py_XDECREF(%(identifier)s);
 template_del_shared_tolerant = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, NULL);
+    Nuitka_Cell_SET(%(identifier)s, NULL);
     Py_XDECREF(old);
 }
 """
@@ -112,7 +112,7 @@ if (likely(%(result)s)) {
 template_del_shared_intolerant = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, NULL);
+    Nuitka_Cell_SET(%(identifier)s, NULL);
     Py_XDECREF(old);
 
     %(result)s = old != NULL;
@@ -128,7 +128,7 @@ Py_DECREF(%(identifier)s);
 template_del_shared_known = """\
 {
     PyObject *old = Nuitka_Cell_GET(%(identifier)s);
-    PyCell_SET(%(identifier)s, NULL);
+    Nuitka_Cell_SET(%(identifier)s, NULL);
 
     CHECK_OBJECT(old);
     Py_DECREF(old);

nuitka/code_generation/templates/TemplateDebugWrapper.py

@@ -6,7 +6,6 @@
 This wraps strings with a class derived from "str" that does more checks.
 """
 
-
 from nuitka import Options
 from nuitka.__past__ import iterItems
 from nuitka.Tracing import optimization_logger

nuitka/code_generation/templates_c/HelperOperationComparisonUnicode.c.j2

@@ -30,20 +30,24 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
         r = false;
     } else {
         int kind1 = PyUnicode_KIND(a);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind1 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)a);
             assert(res != -1);
             kind1 = PyUnicode_KIND(a);
             assert(kind1 != 0);
         }
+#endif
 
         int kind2 = PyUnicode_KIND(b);
+#if PYTHON_VERSION < 0x3c0
         if (unlikely(kind2 == 0)) {
             NUITKA_MAY_BE_UNUSED int res = _PyUnicode_Ready((PyObject *)b);
             assert(res != -1);
             kind2 = PyUnicode_KIND(b);
             assert(kind2 != 0);
         }
+#endif
 
         if (kind1 != kind2) {
             r = false;

nuitka/code_generation/templates_c/HelperSlotsLong.c.j2

@@ -19,11 +19,12 @@
     {{ declare_long_access(right, operand2) }}
 
     if ({{ left.getLongValueDigitCountExpression("operand1")}} <= 1 && {{ right.getLongValueDigitCountExpression("operand2")}} <= 1) {
-        long r = {{ left.getLongValueMediumValueExpression("operand1") }} + {{ right.getLongValueMediumValueExpression("operand2") }};
+        {# TODO: Double digits are not handled efficiently for Python3.12 #}
+        long r = (long)({{ left.getLongValueMediumValueExpression("operand1") }} + {{ right.getLongValueMediumValueExpression("operand2") }});
 
 {% if target == None and left.hasReferenceCounting() %}
         if (Py_REFCNT({{operand1}}) == 1) {
-            Nuitka_LongUpdateFromCLong(&{{operand1}}, r);
+            Nuitka_LongUpdateFromCLong(&{{operand1}}, (long)r);
             {{ goto_exit(props, "exit_result_ok") }}
         } else {
             PyObject *obj = Nuitka_LongFromCLong(r);
@@ -45,7 +46,7 @@
         if (a_negative) {
             if (b_negative) {
                 {{ operand1 }} = _Nuitka_LongAddInplaceDigits({{ operand1 }}, b_digits, b_digit_count);
-                Py_SET_SIZE({{ operand1 }}, -Py_ABS(Py_SIZE({{ operand1 }})));
+                Nuitka_LongSetSignNegative({{ operand1 }});
             } else {
                 {# Reversed operands order means sign inversion. #}
                 {{ operand1 }} = _Nuitka_LongSubInplaceDigits({{ operand1 }}, b_digits, b_digit_count, -1);
@@ -75,7 +76,7 @@
         if (a_negative) {
             if (b_negative) {
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
-                Py_SET_SIZE(z, -(Py_SIZE(z)));
+                Nuitka_LongFlipSign(z);
             } else {
                 {# Reversed operands order. #}
                 z = _Nuitka_LongSubDigits(b_digits, b_digit_count, a_digits, a_digit_count);
@@ -95,7 +96,8 @@
     {{ declare_long_access(right, operand2) }}
 
     if ({{ left.getLongValueDigitCountExpression("operand1")}} <= 1 && {{ right.getLongValueDigitCountExpression("operand2")}} <= 1) {
-        long r = {{ left.getLongValueMediumValueExpression("operand1") }} - {{ right.getLongValueMediumValueExpression("operand2") }};
+        {# TODO: Double digits are not handled efficiently for Python3.12 #}
+        long r = (long)({{ left.getLongValueMediumValueExpression("operand1") }} - {{ right.getLongValueMediumValueExpression("operand2") }});
 
 {% if target == None and left.hasReferenceCounting() %}
         if (Py_REFCNT({{operand1}}) == 1) {
@@ -124,7 +126,7 @@
                 {{ operand1 }} = _Nuitka_LongSubInplaceDigits({{ operand1 }}, b_digits, b_digit_count, -1);
             } else {
                 {{ operand1 }} = _Nuitka_LongAddInplaceDigits({{ operand1 }}, b_digits, b_digit_count);
-                Py_SET_SIZE({{ operand1 }}, -Py_ABS(Py_SIZE({{ operand1 }})));
+                Nuitka_LongSetSignNegative({{ operand1 }});
             }
         } else {
             if (b_negative) {
@@ -155,7 +157,7 @@
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);
             }
 
-            Py_SET_SIZE(z, -(Py_SIZE(z)));
+            Nuitka_LongFlipSign(z);
         } else {
             if (b_negative) {
                 z = _Nuitka_LongAddDigits(a_digits, a_digit_count, b_digits, b_digit_count);

nuitka/containers/Namedtuples.py

@@ -7,7 +7,6 @@ It works around bugs present in some version of Python, and provides extra
 methods like "asDict".
 """
 
-
 from collections import namedtuple
 
 

nuitka/finalizations/Finalization.py

@@ -8,6 +8,7 @@ can be computed here, so the code generation can be quick and doesn't have to
 check it many times.
 
 """
+
 from nuitka.tree import Operations
 
 from .FinalizeMarkups import FinalizeMarkups

nuitka/finalizations/FinalizeMarkups.py

@@ -17,7 +17,6 @@ are in another context.
 
 """
 
-
 from nuitka import Tracing
 from nuitka.__past__ import unicode
 from nuitka.containers.OrderedSets import OrderedSet