Nuitka-winsvc 2.6__cp311-cp311-win_amd64.whl → 2.6.5__cp311-cp311-win_amd64.whl

nuitka/build/static_src/MainProgram.c

@@ -58,6 +58,26 @@
 #include "HelpersConsole.c"
 #endif
 
+// We are open to having this defined otherwise, this is a default only.
+#if defined(_WIN32) && defined(NUITKA_COMPANY_NAME) && defined(NUITKA_PRODUCT_NAME) &&                                 \
+    !defined(NUITKA_APP_MODEL_USER_ID)
+#define NUITKA_APP_MODEL_USER_ID L"" NUITKA_COMPANY_NAME L"." NUITKA_PRODUCT_NAME
+#endif
+
+#if defined(_WIN32) && defined(NUITKA_APP_MODEL_USER_ID)
+typedef HRESULT(WINAPI *pfnSetCurrentProcessExplicitAppUserModelID)(PCWSTR AppID);
+
+static void setCurrentProcessExplicitAppUserModelID(wchar_t const *app_user_model_id) {
+    pfnSetCurrentProcessExplicitAppUserModelID fnSetCurrentProcessExplicitAppUserModelID =
+        (pfnSetCurrentProcessExplicitAppUserModelID)GetProcAddress(GetModuleHandleA("Shell32.dll"),
+                                                                   "SetCurrentProcessExplicitAppUserModelID");
+
+    if (fnSetCurrentProcessExplicitAppUserModelID != NULL) {
+        fnSetCurrentProcessExplicitAppUserModelID(app_user_model_id);
+    }
+}
+#endif
+
 extern PyCodeObject *code_objects_main;
 
 /* For later use in "Py_GetArgcArgv" we expose the needed value  */
@@ -1223,6 +1243,10 @@ int main(int argc, char **argv) {
     inheritAttachedConsole();
 #endif
 
+#if defined(_WIN32) && defined(NUITKA_APP_MODEL_USER_ID)
+    setCurrentProcessExplicitAppUserModelID(NUITKA_APP_MODEL_USER_ID);
+#endif
+
 #ifdef _NUITKA_MACOS_BUNDLE
     {
         char *current_dir = getcwd(NULL, -1);

nuitka/build/static_src/MetaPathBasedLoader.c

@@ -1437,14 +1437,19 @@ static PyObject *getModuleFileValue(PyThreadState *tstate, struct Nuitka_MetaPat
 
     char filename_buffer[1024];
 
-    char const *basename = strrchr(entry->name, '.');
-    if (basename == NULL) {
-        basename = entry->name;
+    if ((entry->flags & NUITKA_PACKAGE_FLAG) != 0) {
+        copyStringSafe(filename_buffer, "__init__", sizeof(filename_buffer));
     } else {
-        basename += 1;
-    }
+        char const *basename = strrchr(entry->name, '.');
+
+        if (basename == NULL) {
+            basename = entry->name;
+        } else {
+            basename += 1;
+        }
 
-    copyStringSafe(filename_buffer, basename, sizeof(filename_buffer));
+        copyStringSafe(filename_buffer, basename, sizeof(filename_buffer));
+    }
 
     if ((entry->flags & NUITKA_EXTENSION_MODULE_FLAG) != 0) {
 #if defined(_WIN32)
@@ -1452,9 +1457,6 @@ static PyObject *getModuleFileValue(PyThreadState *tstate, struct Nuitka_MetaPat
 #else
         appendStringSafe(filename_buffer, ".so", sizeof(filename_buffer));
 #endif
-    } else if ((entry->flags & NUITKA_PACKAGE_FLAG) != 0) {
-        appendCharSafe(filename_buffer, SEP, sizeof(filename_buffer));
-        appendStringSafe(filename_buffer, "__init__.py", sizeof(filename_buffer));
     } else {
         appendStringSafe(filename_buffer, ".py", sizeof(filename_buffer));
     }
@@ -2047,8 +2049,13 @@ void registerMetaPathBasedLoader(struct Nuitka_MetaPathBasedLoaderEntry *_loader
 
                       global_loader);
 
+    // Our "sys.path_hooks" entry uses "os.path" to compare filenames, so we need
+    // to load it without.
+    PyThreadState *tstate = PyThreadState_GET();
+    IMPORT_HARD_OS_PATH(tstate);
+
     // Register it as a sys.path_hook
-    LIST_APPEND1(Nuitka_SysGetObject("path_hooks"), PyObject_GetAttrString(global_loader, "sys_path_hook"));
+    LIST_INSERT_CONST(Nuitka_SysGetObject("path_hooks"), 0, PyObject_GetAttrString(global_loader, "sys_path_hook"));
 }
 
 #if defined(_NUITKA_STANDALONE)

nuitka/build/static_src/OnefileBootstrap.c

@@ -1147,7 +1147,9 @@ int main(int argc, char **argv) {
 
     input.src = payload_current;
     input.pos = 0;
-    input.size = payload_size;
+
+    // TODO: Ought to assert that this doesn't truncate anything.
+    input.size = (size_t)payload_size;
 
     assert(payload_size > 0);
 #else

nuitka/code_generation/TypeAliasCodes.py

@@ -23,7 +23,7 @@ def generateTypeAliasCode(to_name, expression, emit, context):
     )
 
     compute_value_name = generateChildExpressionCode(
-        expression=expression.subnode_compute_value, emit=emit, context=context
+        expression=expression.subnode_value, emit=emit, context=context
     )
 
     assert (
@@ -35,12 +35,13 @@ def generateTypeAliasCode(to_name, expression, emit, context):
         to_name, "type_alias_value", expression, emit, context
     ) as value_name:
         emit(
-            "%s = MAKE_TYPE_ALIAS(%s, %s, %s);"
+            "%s = MAKE_TYPE_ALIAS(%s, %s, %s, %s);"
             % (
                 value_name,
                 context.getConstantCode(constant=type_alias_name),
                 type_params_name,
                 compute_value_name,
+                context.getConstantCode(constant=context.getModuleName().asString()),
             )
         )
 

nuitka/freezer/DllDependenciesMacOS.py

@@ -148,8 +148,11 @@ def _parseOtoolListingOutput(output):
 def _getNonVersionedDllFilenames2(filename):
     yield filename
 
-    if getArchitecture() == "arm64" and filename.endswith(".dylib"):
-        yield filename[:-6] + "_arm64.dylib"
+    if filename.endswith(".dylib"):
+        if getArchitecture() == "arm64":
+            yield filename[:-6] + "_arm64.dylib"
+        else:
+            yield filename[:-6] + "_x86_64.dylib"
 
     match = re.match(r"^(.*?)(\.\d+)+\.dylib$", filename)
 
@@ -161,6 +164,8 @@ def _getNonVersionedDllFilenames2(filename):
         # examples to be sure they are covered with tests.
         if getArchitecture() == "arm64":
             yield match.group(1) + "_arm64.dylib"
+        else:
+            yield match.group(1) + "_x86_64.dylib"
 
     if filename.endswith(".so"):
         yield changeFilenameExtension(filename, ".dylib")

nuitka/freezer/DllDependenciesPosix.py

@@ -12,6 +12,7 @@ from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.PythonFlavors import isAnacondaPython
 from nuitka.Tracing import inclusion_logger
 from nuitka.utils.Execution import executeProcess, withEnvironmentPathAdded
+from nuitka.utils.FileOperations import resolveSymlink
 from nuitka.utils.SharedLibraries import getSharedLibraryRPATH
 from nuitka.utils.Utils import (
     isAlpineLinux,
@@ -30,7 +31,7 @@ ldd_result_cache = {}
 
 def detectBinaryPathDLLsPosix(dll_filename, package_name, original_dir):
     # This is complex, as it also includes the caching mechanism
-    # pylint: disable=too-many-branches
+    # pylint: disable=too-many-branches,too-many-locals
 
     if ldd_result_cache.get(dll_filename):
         return ldd_result_cache[dll_filename]
@@ -46,13 +47,31 @@ def detectBinaryPathDLLsPosix(dll_filename, package_name, original_dir):
         _detected_python_rpath = getSharedLibraryRPATH(sys.executable) or False
 
         if _detected_python_rpath:
+            # Need to resolve a potential symlink.
+            if os.path.islink(sys.executable):
+                sys_executable = os.readlink(sys.executable)
+            else:
+                sys_executable = sys.executable
+
             _detected_python_rpath = _detected_python_rpath.replace(
-                "$ORIGIN", os.path.dirname(sys.executable)
+                "$ORIGIN", os.path.dirname(sys_executable)
+            )
+
+            _detected_python_rpath = os.path.normpath(
+                os.path.join(os.path.dirname(sys.executable), _detected_python_rpath)
             )
 
     # Single one, might be wrong for Anaconda, which uses multiple ones on at least
     # macOS.
-    python_rpaths = (_detected_python_rpath,) if _detected_python_rpath else ()
+    python_rpaths = []
+    if _detected_python_rpath:
+        python_rpaths.append(_detected_python_rpath)
+
+    if os.path.islink(dll_filename):
+        link_target_path = os.path.dirname(
+            os.path.abspath(resolveSymlink(dll_filename))
+        )
+        python_rpaths.append(link_target_path)
 
     # TODO: Actually would be better to pass it as env to the created process instead.
     with withEnvironmentPathAdded(

nuitka/freezer/DllDependenciesWin32.py

@@ -90,6 +90,7 @@ def detectBinaryPathDLLsWin32(
     use_cache,
     update_cache,
 ):
+    # For ARM64 and on user request, we can use "pefile" for dependency detection.
     dependency_tool = (
         "pefile"
         if (getArchitecture() == "arm64" or isExperimental("force-dependencies-pefile"))

nuitka/freezer/IncludedDataFiles.py

@@ -312,8 +312,8 @@ def addIncludedDataFile(included_datafile):
         ) or isFilenameBelowPath(
             path=external_datafile_pattern, filename=included_datafile.dest_path
         ):
+            included_datafile.tags.clear()
             included_datafile.tags.add("inhibit")
-            included_datafile.tags.remove("copy")
 
             return
 

nuitka/freezer/IncludedEntryPoints.py

@@ -352,6 +352,14 @@ def getStandaloneEntryPoints():
     return tuple(standalone_entry_points)
 
 
+def getStandaloneEntryPointForSourceFile(source_path, package_name):
+    for standalone_entry_point in standalone_entry_points:
+        if standalone_entry_point.package_name == package_name and areSamePaths(
+            standalone_entry_point.source_path, source_path
+        ):
+            return standalone_entry_point
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/freezer/Standalone.py

@@ -58,6 +58,7 @@ from .DllDependenciesWin32 import detectBinaryPathDLLsWin32
 from .IncludedEntryPoints import (
     addIncludedEntryPoint,
     getIncludedExtensionModule,
+    getStandaloneEntryPointForSourceFile,
     makeDllEntryPoint,
 )
 
@@ -127,7 +128,7 @@ def _detectBinaryDLLs(
     "otool" (macOS) the list of used DLLs is retrieved.
     """
 
-    if isNuitkaPython():
+    if is_main_executable and isNuitkaPython():
         return OrderedSet()
     elif getOS() in ("Linux", "NetBSD", "FreeBSD", "OpenBSD") or isPosixWindows():
         return detectBinaryPathDLLsPosix(
@@ -384,7 +385,15 @@ Error, cannot detect used DLLs for DLL '%s' in package '%s' due to: %s"""
                     )
                 )
             else:
-                dest_path = os.path.basename(used_dll_path)
+                existing_entry_point = getStandaloneEntryPointForSourceFile(
+                    source_path=used_dll_path,
+                    package_name=standalone_entry_point.package_name,
+                )
+
+                if existing_entry_point is None:
+                    dest_path = os.path.basename(used_dll_path)
+                else:
+                    dest_path = existing_entry_point.dest_path
 
             dll_entry_point = makeDllEntryPoint(
                 logger=inclusion_logger,

nuitka/importing/Importing.py

@@ -439,7 +439,8 @@ ImportScanFinding = collections.namedtuple(
 # We put here things that are not worth it (Cython is not really used by
 # anything really, or where it's know to not have a big # impact, e.g. lxml.
 
-unworthy_namespaces = ("Cython", "lxml")
+# TODO: Do we really want this warning to persist?
+unworthy_namespaces = ("Cython", "lxml", "black", "tomli")
 
 
 def _reportCandidates(package_name, module_name, candidate, candidates):

nuitka/nodes/ChildrenHavingMixins.py

@@ -20544,7 +20544,7 @@ class ChildHavingTypeParamsMixin(object):
 ChildrenExpressionTypeMakeGenericMixin = ChildHavingTypeParamsMixin
 
 
-class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
+class ChildrenHavingTypeParamsTupleValueMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
@@ -20554,7 +20554,7 @@ class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
     def __init__(
         self,
         type_params,
-        compute_value,
+        value,
     ):
         assert type(type_params) is tuple
 
@@ -20563,16 +20563,16 @@ class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
 
         self.subnode_type_params = type_params
 
-        compute_value.parent = self
+        value.parent = self
 
-        self.subnode_compute_value = compute_value
+        self.subnode_value = value
 
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
         result = []
         result.extend(self.subnode_type_params)
-        result.append(self.subnode_compute_value)
+        result.append(self.subnode_value)
         return tuple(result)
 
     def getVisitableNodesNamed(self):
@@ -20583,7 +20583,7 @@ class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
 
         return (
             ("type_params", self.subnode_type_params),
-            ("compute_value", self.subnode_compute_value),
+            ("value", self.subnode_value),
         )
 
     def replaceChild(self, old_node, new_node):
@@ -20602,11 +20602,11 @@ class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
 
             return
 
-        value = self.subnode_compute_value
+        value = self.subnode_value
         if old_node is value:
             new_node.parent = self
 
-            self.subnode_compute_value = new_node
+            self.subnode_value = new_node
 
             return
 
@@ -20620,7 +20620,7 @@ class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
 
         values = {
             "type_params": tuple(v.makeClone() for v in self.subnode_type_params),
-            "compute_value": self.subnode_compute_value.makeClone(),
+            "value": self.subnode_value.makeClone(),
         }
 
         values.update(self.getDetails())
@@ -20633,8 +20633,8 @@ class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
         for c in self.subnode_type_params:
             c.finalize()
         del self.subnode_type_params
-        self.subnode_compute_value.finalize()
-        del self.subnode_compute_value
+        self.subnode_value.finalize()
+        del self.subnode_value
 
     def computeExpressionRaw(self, trace_collection):
         """Compute an expression.
@@ -20673,11 +20673,11 @@ class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
 
         for element in self.subnode_type_params:
             element.collectVariableAccesses(emit_read, emit_write)
-        self.subnode_compute_value.collectVariableAccesses(emit_read, emit_write)
+        self.subnode_value.collectVariableAccesses(emit_read, emit_write)
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionTypeAliasMixin = ChildrenHavingTypeParamsTupleComputeValueMixin
+ChildrenExpressionTypeAliasMixin = ChildrenHavingTypeParamsTupleValueMixin
 
 
 class ChildHavingValueMixin(object):

nuitka/nodes/FunctionNodes.py

@@ -1229,6 +1229,9 @@ class ExpressionFunctionCall(ChildrenHavingFunctionValuesTupleMixin, ExpressionB
 
         values = self.subnode_values
 
+        for value in values:
+            value.onContentEscapes(trace_collection)
+
         # Ask for function for its cost.
         cost = function_body.getFunctionInlineCost(values)
 
@@ -1279,6 +1282,10 @@ class ExpressionFunctionCall(ChildrenHavingFunctionValuesTupleMixin, ExpressionB
     def getClosureVariableVersions(self):
         return self.variable_closure_traces
 
+    def onContentEscapes(self, trace_collection):
+        for value in self.subnode_values:
+            value.onContentEscapes(trace_collection)
+
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.

nuitka/nodes/ModuleNodes.py

@@ -20,7 +20,11 @@ from nuitka.PythonVersions import python_version
 from nuitka.SourceCodeReferences import fromFilename
 from nuitka.tree.SourceHandling import parsePyIFile, readSourceCodeFromFilename
 from nuitka.utils.CStrings import encodePythonIdentifierToC
-from nuitka.utils.Importing import getPackageDirFilename
+from nuitka.utils.FileOperations import switchFilenameExtension
+from nuitka.utils.Importing import (
+    getPackageDirFilename,
+    getSharedLibrarySuffixes,
+)
 from nuitka.utils.ModuleNames import ModuleName
 
 from .ChildrenHavingMixins import (
@@ -1040,14 +1044,18 @@ class PythonExtensionModule(PythonModuleBase):
         """Get Python type description filename."""
 
         path = self.getFilename()
-        filename = os.path.basename(path)
-        dirname = os.path.dirname(path)
 
-        for suffix in (".pyi", ".py"):
-            candidate = os.path.join(dirname, filename.split(".")[0]) + suffix
+        for extension_module_suffix in getSharedLibrarySuffixes():
+            if path.endswith(extension_module_suffix):
+                for pyi_suffix in (".pyi", ".py"):
+                    candidate = switchFilenameExtension(
+                        path=path,
+                        old_extension=extension_module_suffix,
+                        new_extension=pyi_suffix,
+                    )
 
-            if os.path.exists(candidate):
-                return candidate
+                    if os.path.exists(candidate):
+                        return candidate
 
         return None
 
@@ -1055,11 +1063,17 @@ class PythonExtensionModule(PythonModuleBase):
         """Read the .pyi file if present and scan for dependencies."""
 
         if self.used_modules is None:
+            # TODO: Make this a locatePyIFilename function instead.
             pyi_filename = self._getPyIFilename()
 
             if pyi_filename is not None:
                 pyi_deps = parsePyIFile(
                     module_name=self.getFullName(),
+                    package_name=(
+                        self.getFullName()
+                        if self.is_package
+                        else self.getFullName().getPackageName()
+                    ),
                     pyi_filename=pyi_filename,
                 )
 

nuitka/nodes/PackageMetadataNodes.py

@@ -481,7 +481,9 @@ class ImportlibMetadataDistributionCallMixin(object):
         # In module mode, we cannot predict if the distribution is the same or not
         # so lets not optimize this further and treat it as an unknown.
         if shallMakeModule():
-            return
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return self, None, None
 
         distribution_func = self._getImportlibMetadataModule().distribution
         PackageNotFoundError = self._getImportlibMetadataModule().PackageNotFoundError

nuitka/nodes/TypeNodes.py

@@ -334,11 +334,11 @@ class ExpressionSubtypeCheck(
 class ExpressionTypeAlias(ChildrenExpressionTypeAliasMixin, ExpressionBase):
     kind = "EXPRESSION_TYPE_ALIAS"
 
-    named_children = ("type_params|tuple", "compute_value")
+    named_children = ("type_params|tuple", "value")
 
-    def __init__(self, type_params, compute_value, source_ref):
+    def __init__(self, type_params, value, source_ref):
         ChildrenExpressionTypeAliasMixin.__init__(
-            self, type_params=type_params, compute_value=compute_value
+            self, type_params=type_params, value=value
         )
 
         ExpressionBase.__init__(self, source_ref)

nuitka/plugins/PluginBase.py

@@ -1301,7 +1301,8 @@ import sys
 
 try:
 %(setup_codes)s
-except ImportError:
+except ImportError as e:
+    sys.stderr.write("\n%%s" %% repr(e))
     sys.exit(38)
 try:
 %(query_codes)s
@@ -1323,6 +1324,11 @@ except Exception as e:
             feedback = check_output([sys.executable, "-c", cmd], env=env)
         except NuitkaCalledProcessError as e:
             if e.returncode == 38:
+                self.warning(
+                    "Import error (not installed?) during compile time command execution: %s"
+                    % e.stderr.splitlines()[-1]
+                )
+
                 return None
 
             if Options.is_debug:
@@ -1435,7 +1441,8 @@ except Exception as e:
     ):
         if self.isValueForEvaluation(expression):
             return self.evaluateExpression(
-                full_name=full_name,
+                config_module_name=full_name,
+                module_name=full_name,
                 expression=expression,
                 config_name=config_name,
                 extra_context=extra_context,
@@ -1456,6 +1463,8 @@ except Exception as e:
                 if declarations and self.evaluateCondition(
                     full_name=full_name,
                     condition=constant_config.get("when", "True"),
+                    allow_constants=False,
+                    allow_variables=False,
                 ):
                     for constant_name, constant_value in declarations.items():
                         constants[constant_name] = self.evaluateExpressionOrConstant(
@@ -1492,6 +1501,8 @@ except Exception as e:
                 if self.evaluateCondition(
                     full_name=full_name,
                     condition=variable_config.get("when", "True"),
+                    allow_constants=True,
+                    allow_variables=False,
                 ):
                     setup_codes.extend(
                         "%s=%r" % (constant_name, constant_value)
@@ -1534,19 +1545,28 @@ except Exception as e:
         return _module_config_variables[full_name]
 
     def evaluateExpression(
-        self, full_name, expression, config_name, extra_context, single_value
+        self,
+        config_module_name,
+        module_name,
+        expression,
+        config_name,
+        extra_context,
+        single_value,
     ):
         context = _makeEvaluationContext(
-            logger=self, full_name=full_name, config_name=config_name
+            logger=self, full_name=config_module_name, config_name=config_name
         )
 
         def get_variable(variable_name):
             assert type(variable_name) is str, variable_name
 
-            result = self.getExpressionVariables(full_name=full_name)[variable_name]
+            result = self.getExpressionVariables(full_name=config_module_name)[
+                variable_name
+            ]
 
             addModuleInfluencingVariable(
-                module_name=full_name,
+                module_name=module_name,
+                config_module_name=config_module_name,
                 plugin_name=self.plugin_name,
                 variable_name=variable_name,
                 control_tags=context.used_tags,
@@ -1558,7 +1578,9 @@ except Exception as e:
         def get_constant(constant_name):
             assert type(constant_name) is str, constant_name
 
-            result = self.getExpressionConstants(full_name=full_name)[constant_name]
+            result = self.getExpressionConstants(full_name=config_module_name)[
+                constant_name
+            ]
 
             # TODO: Record the constant value in report.
 
@@ -1568,13 +1590,13 @@ except Exception as e:
         context["get_constant"] = get_constant
 
         def get_parameter(parameter_name, default):
-            result = Options.getModuleParameter(full_name, parameter_name)
+            result = Options.getModuleParameter(config_module_name, parameter_name)
 
             if result is None:
                 result = default
 
             self.addModuleInfluencingParameter(
-                module_name=full_name,
+                module_name=config_module_name,
                 parameter_name=parameter_name,
                 condition_tags_used=context.used_tags,
                 result=result,
@@ -1603,16 +1625,16 @@ except Exception as e:
         if type(result) not in (str, unicode):
             if single_value:
                 self._checkStrResult(
-                    value=result, expression=expression, full_name=full_name
+                    value=result, expression=expression, full_name=config_module_name
                 )
             else:
                 self._checkSequenceResult(
-                    value=result, expression=expression, full_name=full_name
+                    value=result, expression=expression, full_name=config_module_name
                 )
 
                 for v in result:
                     self._checkStrResult(
-                        value=v, expression=expression, full_name=full_name
+                        value=v, expression=expression, full_name=config_module_name
                     )
 
                 # Make it immutable in case it's a list.
@@ -1636,7 +1658,9 @@ Error, expression '%s' for module '%s' did not evaluate to 'tuple[str]' or 'list
                 % (expression, full_name)
             )
 
-    def evaluateCondition(self, full_name, condition):
+    def evaluateCondition(
+        self, full_name, condition, allow_constants=True, allow_variables=True
+    ):
         # Note: Caching makes no sense yet, this should all be very fast and
         # cache themselves. TODO: Allow plugins to contribute their own control
         # tag values during creation and during certain actions.
@@ -1650,6 +1674,36 @@ Error, expression '%s' for module '%s' did not evaluate to 'tuple[str]' or 'list
             logger=self, full_name=full_name, config_name="'when' configuration"
         )
 
+        def get_variable(variable_name):
+            assert type(variable_name) is str, variable_name
+
+            result = self.getExpressionVariables(full_name=full_name)[variable_name]
+
+            addModuleInfluencingVariable(
+                module_name=full_name,
+                config_module_name=full_name,
+                plugin_name=self.plugin_name,
+                variable_name=variable_name,
+                control_tags=context.used_tags,
+                result=result,
+            )
+
+            return result
+
+        def get_constant(constant_name):
+            assert type(constant_name) is str, constant_name
+
+            result = self.getExpressionConstants(full_name=full_name)[constant_name]
+
+            # TODO: Record the constant value in report.
+
+            return result
+
+        if allow_constants:
+            context["get_constant"] = get_constant
+        if allow_variables:
+            context["get_variable"] = get_variable
+
         def get_parameter(parameter_name, default):
             result = Options.getModuleParameter(full_name, parameter_name)
 

nuitka/plugins/Plugins.py

@@ -414,7 +414,7 @@ class Plugins(object):
                 if not checkModuleName(v):
                     plugin.sysexit(
                         "Plugin '%s' returned an invalid module name, not %r (for module '%s')"
-                        % (plugin, v, module.getFullName())
+                        % (plugin.plugin_name, v, module.getFullName())
                     )
 
                 yield ModuleName(v)