Nuitka-winsvc 2.1.6__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}
     };
 
@@ -211,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

nuitka/freezer/DllDependenciesMacOS.py

@@ -26,6 +26,7 @@ from nuitka.utils.SharedLibraries import (
     getOtoolDependencyOutput,
     getOtoolListing,
 )
+from nuitka.utils.Utils import getArchitecture
 
 from .DllDependenciesCommon import getLdLibraryPath
 
@@ -50,7 +51,7 @@ def _detectPythonRpaths():
         if os.path.isdir(candidate):
             result.append(candidate)
 
-    return tuple(result)
+    return tuple(set(result))
 
 
 def detectBinaryPathDLLsMacOS(
@@ -93,8 +94,8 @@ def detectBinaryPathDLLsMacOS(
                 original_dir=os.path.dirname(sub_dll_filename),
                 binary_filename=sub_dll_filename,
                 package_name=package_name,
-                recursive=True,
                 keep_unresolved=True,
+                recursive=True,
             )
 
             merged_result.update(sub_result)
@@ -133,6 +134,24 @@ def _parseOtoolListingOutput(output):
     return paths
 
 
+def _getNonVersionedDllFilenames(filename):
+    yield filename
+
+    if getArchitecture() == "arm64" and filename.endswith(".dylib"):
+        yield filename[:-6] + "_arm64.dylib"
+
+    match = re.match(r"^(.*?)(\.\d+)+\.dylib$", filename)
+
+    if match:
+        yield match.group(1) + ".dylib"
+
+        # TODO: The versioned filename, might do the same, and so could the
+        # "x86_64" specific DLL be a thing too, but we should have actual
+        # examples to be sure they are covered with tests.
+        if getArchitecture() == "arm64":
+            yield match.group(1) + "_arm64.dylib"
+
+
 def _resolveBinaryPathDLLsMacOS(
     original_dir, binary_filename, paths, package_specific_dirs, package_name
 ):
@@ -149,11 +168,17 @@ def _resolveBinaryPathDLLsMacOS(
     for path in paths:
         if path.startswith("@rpath/"):
             # Resolve rpath to just the ones given, first match.
+            library_name = path[7:]
+
             for rpath in rpaths:
-                if os.path.exists(os.path.join(rpath, path[7:])):
+                if os.path.exists(os.path.join(rpath, library_name)):
                     resolved_path = os.path.normpath(os.path.join(rpath, path[7:]))
                     break
             else:
+                # These have become virtual in later macOS.
+                if library_name in ("libc++.1.dylib", "libz.1.dylib"):
+                    continue
+
                 # This is only a guess, might be missing package specific directories.
                 resolved_path = os.path.normpath(os.path.join(original_dir, path[7:]))
         elif path.startswith("@loader_path/"):
@@ -189,22 +214,33 @@ def _resolveBinaryPathDLLsMacOS(
                 )
 
         # Some extension modules seem to reference themselves by a different
-        # extension module name, so use that if it exists.
-        if not os.path.exists(resolved_path) and python_version >= 0x300:
+        # extension module name, so use that if it exists, and some versioned
+        # DLL dependencies do not matter.
+        if python_version >= 0x300:
             so_suffixes = getSharedLibrarySuffixes()[:-1]
 
             specific_suffix = so_suffixes[0]
             abi_suffix = so_suffixes[1]
 
-            if resolved_path.endswith(specific_suffix):
-                candidate = resolved_path[: -len(specific_suffix)] + abi_suffix
-            elif resolved_path.endswith(abi_suffix):
-                candidate = resolved_path[: -len(specific_suffix)] + abi_suffix
-            else:
-                candidate = None
+            for resolved_path_candidate in _getNonVersionedDllFilenames(resolved_path):
+                if os.path.exists(resolved_path_candidate):
+                    resolved_path = resolved_path_candidate
+                    break
 
-            if candidate is not None and os.path.exists(candidate):
-                resolved_path = candidate
+                if resolved_path_candidate.endswith(specific_suffix):
+                    candidate = (
+                        resolved_path_candidate[: -len(specific_suffix)] + abi_suffix
+                    )
+                elif resolved_path_candidate.endswith(abi_suffix):
+                    candidate = (
+                        resolved_path_candidate[: -len(specific_suffix)] + abi_suffix
+                    )
+                else:
+                    candidate = None
+
+                if candidate is not None and os.path.exists(candidate):
+                    resolved_path = candidate
+                    break
 
         # Sometimes self-dependencies are on a numbered version, but deployed is
         # one version without it. The macOS just ignores that, and so we do.
@@ -241,6 +277,17 @@ def _resolveBinaryPathDLLsMacOS(
             # TODO: Missing DLLs that are accepted, are not really forbidden, we
             # should instead acknowledge them as missing, and treat that properly
             # in using code.
+            if acceptable is True:
+                raise NuitkaForbiddenDLLEncounter(binary_filename, plugin_name)
+
+            # We check both the user and the used DLL if they are listed. This
+            # might be a form of bug hiding, that the later is not sufficient,
+            # that we should address later.
+            acceptable, plugin_name = Plugins.isAcceptableMissingDLL(
+                package_name=package_name,
+                filename=resolved_path,
+            )
+
             if acceptable is True:
                 raise NuitkaForbiddenDLLEncounter(binary_filename, plugin_name)