Nuitka-winsvc 2.3.11__cp311-cp311-win_amd64.whl → 2.4.1__cp311-cp311-win_amd64.whl

nuitka/code_generation/CodeGeneration.py

@@ -250,7 +250,6 @@ from .MatchCodes import generateMatchArgsCode
 from .ModuleCodes import (
     generateModuleAttributeCode,
     generateModuleAttributeFileCode,
-    generateNuitkaLoaderCreationCode,
     getModuleCode,
 )
 from .NetworkxCodes import generateNetworkxUtilsDecoratorsArgmapCallCode
@@ -651,8 +650,10 @@ addExpressionDispatchDict(
         "EXPRESSION_BUILTIN_ISSUBCLASS": generateBuiltinIssubclassCode,
         "EXPRESSION_TYPE_CHECK": generateTypeCheckCode,
         "EXPRESSION_SUBTYPE_CHECK": generateSubtypeCheckCode,
+        "EXPRESSION_MATCH_ARGS": generateMatchArgsCode,
         "EXPRESSION_MATCH_TYPE_CHECK_SEQUENCE": generateMatchTypeCheckSequenceCode,
         "EXPRESSION_MATCH_TYPE_CHECK_MAPPING": generateMatchTypeCheckMappingCode,
+        "EXPRESSION_MATCH_SUBSCRIPT_CHECK": generateMatchSubscriptCheckCode,
         "EXPRESSION_BUILTIN_DIR1": generateBuiltinDir1Code,
         "EXPRESSION_BUILTIN_VARS": generateBuiltinVarsCode,
         "EXPRESSION_BUILTIN_HASATTR": generateBuiltinHasattrCode,
@@ -773,6 +774,7 @@ addExpressionDispatchDict(
         "EXPRESSION_IMPORT_MODULE_HARD": generateImportModuleHardCode,
         "EXPRESSION_IMPORT_MODULE_NAME_HARD_MAYBE_EXISTS": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORT_MODULE_NAME_HARD_EXISTS": generateImportModuleNameHardCode,
+        "EXPRESSION_BUILTIN_PATCHABLE_TYPE_REF": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORTLIB_IMPORT_MODULE_REF": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORTLIB_IMPORT_MODULE_CALL": generateImportlibImportCallCode,
         "EXPRESSION_IMPORT_NAME": generateImportNameCode,
@@ -843,12 +845,11 @@ addExpressionDispatchDict(
         "EXPRESSION_OPERATION_NOT": generateOperationNotCode,
         "EXPRESSION_OUTLINE_BODY": generateFunctionOutlineCode,
         "EXPRESSION_OUTLINE_FUNCTION": generateFunctionOutlineCode,
-        # TODO: Rename to make more clear it is an outline
-        "EXPRESSION_CLASS_BODY_P2": generateFunctionOutlineCode,
-        "EXPRESSION_CLASS_BODY_P3": generateFunctionOutlineCode,
+        "EXPRESSION_CLASS_MAPPING_BODY": generateFunctionOutlineCode,
+        "EXPRESSION_CLASS_DICT_BODY": generateFunctionOutlineCode,
+        "EXPRESSION_CLASS_DICT_BODY_P2": generateFunctionOutlineCode,
         "EXPRESSION_SUBSCRIPT_LOOKUP": generateSubscriptLookupCode,
         "EXPRESSION_SUBSCRIPT_LOOKUP_FOR_UNPACK": generateSubscriptLookupCode,
-        "EXPRESSION_MATCH_SUBSCRIPT_CHECK": generateMatchSubscriptCheckCode,
         "EXPRESSION_SLICE_LOOKUP": generateSliceLookupCode,
         "EXPRESSION_SET_OPERATION_UPDATE": generateSetOperationUpdateCode,
         "EXPRESSION_SIDE_EFFECTS": generateSideEffectsCode,
@@ -872,7 +873,6 @@ addExpressionDispatchDict(
         "EXPRESSION_LOCALS_VARIABLE_REF_OR_FALLBACK": generateLocalsDictVariableRefOrFallbackCode,
         "EXPRESSION_LOCALS_VARIABLE_REF": generateLocalsDictVariableRefCode,
         "EXPRESSION_RAISE_EXCEPTION": generateRaiseExpressionCode,
-        "EXPRESSION_NUITKA_LOADER_CREATION": generateNuitkaLoaderCreationCode,
         "EXPRESSION_PKGUTIL_GET_DATA_REF": generateImportModuleNameHardCode,
         "EXPRESSION_PKG_RESOURCES_REQUIRE_REF": generateImportModuleNameHardCode,
         "EXPRESSION_PKG_RESOURCES_GET_DISTRIBUTION_REF": generateImportModuleNameHardCode,
@@ -945,7 +945,6 @@ addExpressionDispatchDict(
         "EXPRESSION_OS_PATH_NORMPATH_CALL": generateOsPathNormpathCallCode,
         "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.

nuitka/code_generation/ConstantCodes.py

@@ -17,11 +17,16 @@ import os
 import sys
 
 from nuitka import Options
+from nuitka.__past__ import unicode
+from nuitka.containers.Namedtuples import makeNamedtupleClass
 from nuitka.ModuleRegistry import getRootTopModule
 from nuitka.PythonVersions import python_version
 from nuitka.Serialization import GlobalConstantAccessor
 from nuitka.utils.CStrings import encodePythonStringToC
-from nuitka.utils.Distributions import getDistributionTopLevelPackageNames
+from nuitka.utils.Distributions import (
+    getDistribution,
+    getDistributionTopLevelPackageNames,
+)
 from nuitka.Version import getNuitkaVersionTuple
 
 from .CodeHelpers import withObjectCodeTemporaryAssignment
@@ -129,7 +134,19 @@ def getConstantsDefinitionCode():
                 sys.base_exec_prefix
             )
 
-    metadata_values_code = constant_accessor.getConstantCode(metadata_values)
+    runtime_metadata_values = tuple(
+        (
+            distribution_name,
+            (
+                metadata_value.module_name,
+                metadata_value.metadata,
+                metadata_value.entry_points_data,
+            ),
+        )
+        for distribution_name, metadata_value in sorted(metadata_values.items())
+    )
+
+    metadata_values_code = constant_accessor.getConstantCode(runtime_metadata_values)
 
     lines.insert(
         0,
@@ -164,24 +181,50 @@ def getConstantsDefinitionCode():
     return header, body
 
 
+MetaDataDescription = makeNamedtupleClass(
+    "MetaDataDescription",
+    (
+        "module_name",
+        "metadata",
+        "entry_points_data",
+        "reasons",
+    ),
+)
+
 metadata_values = {}
 
 
-def addDistributionMetadataValue(name, distribution):
+def addDistributionMetadataValue(distribution_name, distribution, reason):
+    assert type(distribution_name) in (str, unicode), distribution_name
+
     # Extract what we need to from the distribution object.
-    metadata = str(
-        distribution.read_text("METADATA") or distribution.read_text("PKG-INFO") or ""
-    )
+    if distribution_name not in metadata_values:
+        # The user doesn't have this handy.
+        if distribution is None:
+            distribution = getDistribution(distribution_name)
+
+        metadata = str(
+            distribution.read_text("METADATA")
+            or distribution.read_text("PKG-INFO")
+            or ""
+        )
 
-    entry_points = str(distribution.read_text("entry_points.txt") or "")
+        entry_points_data = str(distribution.read_text("entry_points.txt") or "")
 
-    package_name = getDistributionTopLevelPackageNames(distribution)[0]
+        module_name = getDistributionTopLevelPackageNames(distribution)[0]
 
-    metadata_values[name] = (package_name, metadata, entry_points)
+        metadata_values[distribution_name] = MetaDataDescription(
+            module_name=module_name,
+            metadata=metadata,
+            entry_points_data=entry_points_data,
+            reasons=[reason],
+        )
+    else:
+        metadata_values[distribution_name].reasons.append(reason)
 
 
 def getDistributionMetadataValues():
-    return sorted(tuple(metadata_values.items()))
+    return sorted(metadata_values.items())
 
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/code_generation/GlobalConstants.py

@@ -136,11 +136,8 @@ def getConstantDefaultPopulation():
         # Modules have that attribute starting with Python3
         result.append("__loader__")
 
-    if python_version >= 0x340:
-        result.append(
-            # YIELD_FROM uses this starting 3.4, with 3.3 other code is used.
-            "send"
-        )
+        # YIELD_FROM uses this
+        result.append("send")
 
     if python_version >= 0x300:
         result += (
@@ -175,7 +172,7 @@ def getConstantDefaultPopulation():
         if python_version < 0x300:
             result.append("long")
 
-    if python_version >= 0x340:
+    if python_version >= 0x300:
         # Work with the __spec__ module attribute.
         result += ("__spec__", "_initializing", "parent")
 
@@ -215,6 +212,9 @@ def getConstantDefaultPopulation():
         result.append("__aenter__")
         result.append("__aexit__")
 
+        # Exception group split method call
+        result.append("split")
+
     if isWin32Windows():
         result.append("fileno")
 

nuitka/code_generation/Indentation.py

@@ -8,10 +8,9 @@ to be the same as in templates.
 """
 
 
-def _indentedCode(codes, count):
+def _indentedCode(codes, prefix):
     return "\n".join(
-        " " * count + line if (line and not line.startswith("#")) else line
-        for line in codes
+        prefix + line if (line and line[0] != "#") else line for line in codes
     )
 
 
@@ -23,7 +22,7 @@ def indented(codes, level=1, vert_block=False):
         codes.insert(0, "")
         codes.append("")
 
-    return _indentedCode(codes, level * 4)
+    return _indentedCode(codes, " " * level)
 
 
 def getCommentCode(comment, emit):

nuitka/code_generation/LoaderCodes.py

@@ -85,6 +85,9 @@ def getModuleMetaPathLoaderEntryCode(module, bytecode_accessor):
     elif module.isPythonExtensionModule():
         flags.append("NUITKA_EXTENSION_MODULE_FLAG")
 
+        if module.isExtensionModulePackage():
+            flags.append("NUITKA_PACKAGE_FLAG")
+
         return template_metapath_loader_extension_module_entry % {
             "module_name": module_c_name,
             "flags": " | ".join(flags),

nuitka/code_generation/LocalsDictCodes.py

@@ -22,7 +22,8 @@ from .PythonAPICodes import getReferenceExportCode
 from .templates.CodeTemplatesVariables import (
     template_read_locals_dict_with_fallback,
     template_read_locals_dict_without_fallback,
-    template_read_locals_mapping_with_fallback,
+    template_read_locals_mapping_with_fallback_no_ref,
+    template_read_locals_mapping_with_fallback_ref,
     template_read_locals_mapping_without_fallback,
 )
 
@@ -95,11 +96,11 @@ def generateLocalsDictSetCode(statement, emit, context):
 
     is_dict = locals_scope.hasShapeDictionaryExact()
 
-    res_name = context.getIntResName()
-
     if is_dict:
+        res_name = context.getBoolResName()
+
         emit(
-            "%s = PyDict_SetItem(%s, %s, %s);"
+            "%s = DICT_SET_ITEM(%s, %s, %s);"
             % (
                 res_name,
                 locals_declaration,
@@ -107,7 +108,17 @@ def generateLocalsDictSetCode(statement, emit, context):
                 value_arg_name,
             )
         )
+
+        getErrorExitBoolCode(
+            condition="%s == false" % res_name,
+            release_name=value_arg_name,
+            needs_check=statement.mayRaiseException(BaseException),
+            emit=emit,
+            context=context,
+        )
     else:
+        res_name = context.getIntResName()
+
         emit(
             "%s = PyObject_SetItem(%s, %s, %s);"
             % (
@@ -118,13 +129,13 @@ def generateLocalsDictSetCode(statement, emit, context):
             )
         )
 
-    getErrorExitBoolCode(
-        condition="%s != 0" % res_name,
-        release_name=value_arg_name,
-        needs_check=statement.mayRaiseException(BaseException),
-        emit=emit,
-        context=context,
-    )
+        getErrorExitBoolCode(
+            condition="%s != 0" % res_name,
+            release_name=value_arg_name,
+            needs_check=statement.mayRaiseException(BaseException),
+            emit=emit,
+            context=context,
+        )
 
 
 def generateLocalsDictDelCode(statement, emit, context):
@@ -194,7 +205,7 @@ def generateLocalsDictVariableRefOrFallbackCode(to_name, expression, emit, conte
 
         is_dict = locals_scope.hasShapeDictionaryExact()
 
-        assert not context.needsCleanup(value_name)
+        needs_ref = context.needsCleanup(value_name)
 
         if is_dict:
             template = template_read_locals_dict_with_fallback
@@ -205,12 +216,22 @@ def generateLocalsDictVariableRefOrFallbackCode(to_name, expression, emit, conte
                 % {
                     "to_name": value_name,
                     "locals_dict": locals_declaration,
+                    "dict_get_item": (
+                        "DICT_GET_ITEM1" if needs_ref else "DICT_GET_ITEM0"
+                    ),
                     "fallback": fallback_codes,
                     "var_name": context.getConstantCode(constant=variable_name),
                 }
             )
+
+            if needs_ref:
+                context.addCleanupTempName(value_name)
         else:
-            template = template_read_locals_mapping_with_fallback
+            if needs_ref:
+                template = template_read_locals_mapping_with_fallback_ref
+            else:
+                template = template_read_locals_mapping_with_fallback_no_ref
+
             fallback_codes = indented(fallback_emit.codes, 2)
 
             emit(
@@ -226,7 +247,8 @@ def generateLocalsDictVariableRefOrFallbackCode(to_name, expression, emit, conte
 
             # If the fallback took no reference, then make it do it
             # anyway.
-            context.addCleanupTempName(value_name)
+            if not needs_ref:
+                context.addCleanupTempName(value_name)
 
 
 def generateLocalsDictVariableRefCode(to_name, expression, emit, context):

nuitka/code_generation/MatchCodes.py

@@ -13,20 +13,39 @@ from .ErrorCodes import getErrorExitCode
 
 
 def generateMatchArgsCode(to_name, expression, emit, context):
-    (matched_name,) = generateChildExpressionsCode(
+    (matched_value_name, match_type_name) = generateChildExpressionsCode(
         expression=expression, emit=emit, context=context
     )
 
+    # TODO: Prefer "PyObject **" of course once we have that.
+    keywords = expression.getKeywordArgs()
+
+    if keywords:
+        keywords_name = context.getConstantCode(constant=keywords)
+        keywords_name = "&PyTuple_GET_ITEM(%s, 0)" % keywords_name
+    else:
+        keywords_name = "NULL"
+
     with withObjectCodeTemporaryAssignment(
         to_name, "match_args_value", expression, emit, context
     ) as value_name:
         emit(
-            "%s = MATCH_CLASS_ARGS(tstate, %s, %d);"
-            % (value_name, matched_name, expression.max_allowed)
+            "%s = MATCH_CLASS_ARGS(tstate, %s, %s, %d, %s, %d);"
+            % (
+                value_name,
+                matched_value_name,
+                match_type_name,
+                expression.getPositionalArgsCount(),
+                keywords_name,
+                len(keywords),
+            )
         )
 
         getErrorExitCode(
-            check_name=value_name, release_name=matched_name, emit=emit, context=context
+            check_name=value_name,
+            release_names=(matched_value_name, match_type_name),
+            emit=emit,
+            context=context,
         )
 
         context.addCleanupTempName(value_name)

nuitka/code_generation/ModuleCodes.py

@@ -180,13 +180,6 @@ def generateModuleAttributeCode(to_name, expression, emit, context):
     )
 
 
-def generateNuitkaLoaderCreationCode(to_name, expression, emit, context):
-    with withObjectCodeTemporaryAssignment(
-        to_name, "nuitka_loader_value", expression, emit, context
-    ) as result_name:
-        emit("%s = Nuitka_Loader_New(loader_entry);" % result_name)
-
-
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/code_generation/Namify.py

@@ -33,6 +33,8 @@ def namifyConstant(constant):
     if constant_type is int:
         if constant == 0:
             result = "int_0"
+        elif constant < -10000000 or constant > 10000000:
+            result = "int_hex_%s" % hex(constant)[2:]
         elif constant > 0:
             result = "int_pos_%d" % constant
         else:

nuitka/code_generation/PackageResourceCodes.py

@@ -160,7 +160,11 @@ def generateImportlibMetadataDistributionValueCode(to_name, expression, emit, co
     distribution = expression.distribution
     original_name = expression.original_name
 
-    addDistributionMetadataValue(name=original_name, distribution=distribution)
+    addDistributionMetadataValue(
+        distribution_name=original_name,
+        distribution=distribution,
+        reason="static analysis",
+    )
 
     with withObjectCodeTemporaryAssignment(
         to_name, "distribution_value", expression, emit, context

nuitka/code_generation/templates/CodeTemplatesConstants.py

@@ -3,6 +3,7 @@
 
 """ Templates for the constants handling.
 
+spell-checker: ignore structseq
 """
 
 template_constants_reading = r"""
@@ -56,7 +57,7 @@ NUITKA_MAY_BE_UNUSED static PyObject *STRIP_DIRNAME(PyObject *path) {
 }
 #endif
 
-extern void setDistributionsMetadata(PyObject *metadata_values);
+extern void setDistributionsMetadata(PyThreadState *tstate, PyObject *metadata_items);
 
 // We provide the sys.version info shortcut as a global value here for ease of use.
 PyObject *Py_SysVersionInfo = NULL;
@@ -113,7 +114,8 @@ static void _createGlobalConstants(PyThreadState *tstate) {
 
     static PyTypeObject Nuitka_VersionInfoType;
 
-    // Same fields as "sys.version_info" except no serial number.
+    // Same fields as "sys.version_info" except no serial number
+    // spell-checker: ignore releaselevel
     static PyStructSequence_Field Nuitka_VersionInfoFields[] = {
         {(char *)"major", (char *)"Major release number"},
         {(char *)"minor", (char *)"Minor release number"},
@@ -150,7 +152,6 @@ 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);
@@ -229,7 +230,8 @@ static void _createGlobalConstants(PyThreadState *tstate) {
     Nuitka_VersionInfoType.tp_init = NULL;
     Nuitka_VersionInfoType.tp_new = NULL;
 
-    setDistributionsMetadata(%(metadata_values)s);
+    // Register included meta data.
+    setDistributionsMetadata(tstate, %(metadata_values)s);
 }
 
 // In debug mode we can check that the constants were not tampered with in any

nuitka/code_generation/templates/CodeTemplatesLoader.py

@@ -82,7 +82,7 @@ void setupMetaPathBasedLoader(PyThreadState *tstate) {
     static bool init_done = false;
     if (init_done == false) {
         _loadBytesCodesBlob(tstate);
-        registerMetaPathBasedUnfreezer(meta_path_loader_entries, bytecode_data);
+        registerMetaPathBasedLoader(meta_path_loader_entries, bytecode_data);
 
         init_done = true;
     }

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -59,7 +59,7 @@ static bool constants_created = false;
 /* Function to create module private constants. */
 static void createModuleConstants(PyThreadState *tstate) {
     if (constants_created == false) {
-        loadConstantsBlob(tstate, &mod_consts[0], UNTRANSLATE(%(module_const_blob_name)s));
+        loadConstantsBlob(tstate, &mod_consts[0], UN_TRANSLATE(%(module_const_blob_name)s));
         constants_created = true;
 
 #ifndef __NUITKA_NO_ASSERT__
@@ -164,7 +164,7 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
 
     if (offset == -5) {
         CHECK_OBJECT(function->m_constant_return_value);
-        PyTuple_SET_ITEM0(result, 5, function->m_constant_return_value);
+        PyTuple_SET_ITEM_IMMORTAL(result, 5, function->m_constant_return_value);
     } else {
         PyTuple_SET_ITEM_IMMORTAL(result, 5, Py_None);
     }
@@ -404,7 +404,7 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
         UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___builtins__, value);
     }
 
-    UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type);
+    UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___loader__, Nuitka_Loader_New(loader_entry));
 
 #if PYTHON_VERSION >= 0x340
 // Set the "__spec__" value

nuitka/code_generation/templates/CodeTemplatesVariables.py

@@ -157,7 +157,7 @@ template_read_mvar_unclear = """\
 """
 
 template_read_locals_dict_with_fallback = """\
-%(to_name)s = DICT_GET_ITEM0(tstate, %(locals_dict)s, %(var_name)s);
+%(to_name)s = %(dict_get_item)s(tstate, %(locals_dict)s, %(var_name)s);
 
 if (%(to_name)s == NULL) {
 %(fallback)s
@@ -169,7 +169,9 @@ template_read_locals_dict_without_fallback = """\
 """
 
 
-template_read_locals_mapping_with_fallback = """\
+# Fallback has no ref, so take one to agree with PyObject_GetItem doing
+# it.
+template_read_locals_mapping_with_fallback_no_ref = """\
 %(to_name)s = PyObject_GetItem(%(locals_dict)s, %(var_name)s);
 
 if (%(to_name)s == NULL) {
@@ -182,6 +184,18 @@ if (%(to_name)s == NULL) {
 }
 """
 
+template_read_locals_mapping_with_fallback_ref = """\
+%(to_name)s = PyObject_GetItem(%(locals_dict)s, %(var_name)s);
+
+if (%(to_name)s == NULL) {
+    if (CHECK_AND_CLEAR_KEY_ERROR_OCCURRED(tstate)) {
+%(fallback)s
+    } else {
+        goto %(exception_exit)s;
+    }
+}
+"""
+
 template_read_locals_mapping_without_fallback = """\
 %(to_name)s = PyObject_GetItem(%(locals_dict)s, %(var_name)s);
 """

nuitka/code_generation/templates_c/CodeTemplateCallsMethodPositional.c.j2

@@ -42,7 +42,7 @@ PyObject *CALL_METHOD_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject *s
             if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
                 func = Py_TYPE(descr)->tp_descr_get;
 
-                if (func != NULL && PyDescr_IsData(descr)) {
+                if (func != NULL && Nuitka_Descr_IsData(descr)) {
                     PyObject *called_object = func(descr, source, (PyObject *)type);
                     Py_DECREF(descr);
 
@@ -262,7 +262,7 @@ PyObject *CALL_METHOD_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject *s
         if (NuitkaType_HasFeatureClass(Py_TYPE(descr))) {
             func = Py_TYPE(descr)->tp_descr_get;
 
-            if (func != NULL && PyDescr_IsData(descr)) {
+            if (func != NULL && Nuitka_Descr_IsData(descr)) {
                 PyObject *called_object = func(descr, source, (PyObject *)type);
                 Py_DECREF(descr);
 

nuitka/code_generation/templates_c/HelperOperationBinary.c.j2

@@ -15,7 +15,7 @@
 #endif
 
     {% set props = {"exits": {}} %}
-    {{ binary_operation(props, operator, nb_slot, left, right, "type1", "type2", "operand1", "operand2", "exit_binary_result_object", "exit_binary_result_cbool_ok", "exit_binary_result_nbool", "exit_binary_exception") }}
+    {{ binary_operation(props, operator, False, nb_slot, left, right, "type1", "type2", "operand1", "operand2", "exit_binary_result_object", "exit_binary_result_cbool_ok", "exit_binary_result_nbool", "exit_binary_exception") }}
 
 {% if "exit_binary_result_object" in props["exits"] %}
 exit_binary_result_object:

nuitka/code_generation/templates_c/HelperOperationInplace.c.j2

@@ -30,7 +30,7 @@
 {% endif %}
 
     {
-        {{ binary_operation(props, operator, nb_slot, left, right, "type1", "type2", "*operand1", "operand2", "exit_inplace_result_object", "exit_inplace_result_cbool_ok", "exit_inplace_result_nbool", "exit_inplace_exception") }}
+        {{ binary_operation(props, operator, True, nb_slot, left, right, "type1", "type2", "*operand1", "operand2", "exit_inplace_result_object", "exit_inplace_result_cbool_ok", "exit_inplace_result_nbool", "exit_inplace_exception") }}
     }
 
 {% if "exit_inplace_result_object" in props["exits"] %}

nuitka/code_generation/templates_c/HelperSlotsBinary.c.j2

@@ -10,7 +10,7 @@
 {% from 'HelperSlotsTuple.c.j2' import tuple_slot %}
 {% from 'HelperSlotsList.c.j2' import list_slot %}
 {% from 'HelperSlotsSet.c.j2' import set_slot %}
-{% macro operation_unsupported_error_exit(props, operator, left, right, type1, type2, exit_result_exception) %}
+{% macro operation_unsupported_error_exit(props, operator, inplace, left, right, type1, type2, exit_result_exception) %}
 {% set args = [] %}
 {% if left == object_desc %}
 {% do args.append("%s->tp_name" % type1) %}
@@ -24,15 +24,15 @@
 {% set right_name_3 = "'%s'" % ("%s" if right == object_desc else right.getTypeName3()) %}
 {% if (left_name_2 == left_name_3 and right_name_2 == right_name_3) or left.python_requirement or right.python_requirement %}
 {% if left.python_requirement == "PYTHON_VERSION < 0x300" or right.python_requirement == "PYTHON_VERSION < 0x300" %}
-    PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for {{ left.getOperationErrorMessageName(operator) }}: {{ left_name_2 }} and {{ right_name_2 }}"{{ "," + ",".join(args) if args else "" }});
+    PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for {{ left.getOperationErrorMessageName(operator, inplace) }}: {{ left_name_2 }} and {{ right_name_2 }}"{{ "," + ",".join(args) if args else "" }});
 {% else %}
-    PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for {{ left.getOperationErrorMessageName(operator) }}: {{ left_name_3 }} and {{ right_name_3 }}"{{ "," + ",".join(args) if args else "" }});
+    PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for {{ left.getOperationErrorMessageName(operator, inplace) }}: {{ left_name_3 }} and {{ right_name_3 }}"{{ "," + ",".join(args) if args else "" }});
 {% endif %}
 {% else %}
 #if PYTHON_VERSION < 0x300
-    PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for {{ left.getOperationErrorMessageName(operator) }}: {{ left_name_2 }} and {{ right_name_2 }}"{{ "," + ",".join(args) if args else "" }});
+    PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for {{ left.getOperationErrorMessageName(operator, inplace) }}: {{ left_name_2 }} and {{ right_name_2 }}"{{ "," + ",".join(args) if args else "" }});
 #else
-    PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for {{ left.getOperationErrorMessageName(operator) }}: {{ left_name_3 }} and {{ right_name_3 }}"{{ "," + ",".join(args) if args else "" }});
+    PyErr_Format(PyExc_TypeError, "unsupported operand type(s) for {{ left.getOperationErrorMessageName(operator, inplace) }}: {{ left_name_3 }} and {{ right_name_3 }}"{{ "," + ",".join(args) if args else "" }});
 #endif
 {% endif %}
     {{ goto_exit(props, exit_result_exception) }}
@@ -129,7 +129,7 @@
         }
     }
 {% endmacro %}
-{% macro binary_operation(props, operator, nb_slot, left, right, type1, type2, operand1, operand2, exit_result_object, exit_result_cbool_ok, exit_result_nbool, exit_result_exception) %}
+{% macro binary_operation(props, operator, inplace, nb_slot, left, right, type1, type2, operand1, operand2, exit_result_object, exit_result_cbool_ok, exit_result_nbool, exit_result_exception) %}
 {% set slot1_relevant = left == object_desc or left.hasSlot(nb_slot) %}
 {% set slot2_relevant = right == object_desc or (left != right and right.hasSlot(nb_slot)) %}
 {% set error_needed = 1 %}
@@ -375,7 +375,7 @@
 {% endif %}
 
 {% if error_needed == 1 %}
-    {{ operation_unsupported_error_exit(props, operator, left, right, type1, type2, exit_result_exception) }}
+    {{ operation_unsupported_error_exit(props, operator, inplace, left, right, type1, type2, exit_result_exception) }}
 {% else %}
     NUITKA_CANNOT_GET_HERE("missing error exit annotation");
 {% endif %}

nuitka/freezer/DependsExe.py

@@ -44,6 +44,7 @@ def getDependsExePath():
         url=depends_url,
         is_arch_specific=getArchitecture(),
         binary="depends.exe",
+        unzip=True,
         flatten=True,
         specificity="",  # Note: If there ever was an update, put version here.
         message="""\
@@ -213,7 +214,8 @@ SxS
 
     if not os.path.exists(output_filename):
         inclusion_logger.sysexit(
-            "Error, 'depends.exe' failed to produce expected output."
+            "Error, 'depends.exe' failed to produce expected output for binary '%s'."
+            % binary_filename
         )
 
     # Opening the result under lock, so it is not getting locked by new processes.