Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/plugins/PluginBase.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """
 Plugins: Welcome to Nuitka! This is your shortest way to become part of it.
 
@@ -31,9 +17,10 @@ import functools
 import inspect
 import os
 import sys
+import unittest
 
 from nuitka import Options
-from nuitka.__past__ import getMetaClassBase
+from nuitka.__past__ import iter_modules, unicode
 from nuitka.containers.Namedtuples import makeNamedtupleClass
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.freezer.IncludedDataFiles import (
@@ -50,27 +37,53 @@ from nuitka.freezer.IncludedEntryPoints import (
 )
 from nuitka.ModuleRegistry import (
     addModuleInfluencingCondition,
+    addModuleInfluencingDetection,
+    addModuleInfluencingParameter,
+    addModuleInfluencingVariable,
     getModuleInclusionInfoByName,
 )
 from nuitka.Options import (
-    hasPythonFlagNoAnnotations,
-    hasPythonFlagNoAsserts,
-    hasPythonFlagNoDocStrings,
+    getCompanyName,
+    getFileVersion,
+    getProductFileVersion,
+    getProductName,
+    getProductVersion,
     isDeploymentMode,
+    isOnefileMode,
+    isOnefileTempDirMode,
     isStandaloneMode,
     shallCreateAppBundle,
     shallMakeModule,
     shallShowExecutedCommands,
 )
-from nuitka.PythonFlavors import isAnacondaPython, isDebianPackagePython
+from nuitka.PythonFlavors import (
+    isAnacondaPython,
+    isDebianPackagePython,
+    isNuitkaPython,
+)
 from nuitka.PythonVersions import (
     getTestExecutionPythonVersions,
     python_version,
+    python_version_full_str,
+    python_version_str,
 )
 from nuitka.Tracing import plugins_logger
-from nuitka.utils.Distributions import isDistributionCondaPackage
-from nuitka.utils.Execution import NuitkaCalledProcessError, check_output
-from nuitka.utils.Importing import isBuiltinModuleName
+from nuitka.utils.AppDirs import getAppdirsModule
+from nuitka.utils.Distributions import (
+    getDistributionFromModuleName,
+    getDistributionName,
+    isDistributionCondaPackage,
+)
+from nuitka.utils.Execution import (
+    NuitkaCalledProcessError,
+    check_output,
+    withEnvironmentVarsOverridden,
+)
+from nuitka.utils.FileOperations import (
+    changeFilenameExtension,
+    getFileContents,
+)
+from nuitka.utils.Importing import getSharedLibrarySuffix, isBuiltinModuleName
 from nuitka.utils.ModuleNames import (
     ModuleName,
     makeTriggerModuleName,
@@ -78,11 +91,15 @@ from nuitka.utils.ModuleNames import (
     pre_module_load_trigger_name,
 )
 from nuitka.utils.SharedLibraries import locateDLL, locateDLLsInDirectory
+from nuitka.utils.SlotMetaClasses import getMetaClassBase
+from nuitka.utils.StaticLibraries import getSystemStaticLibPythonPath
 from nuitka.utils.Utils import (
     getArchitecture,
+    isAndroidBasedLinux,
     isLinux,
     isMacOS,
     isWin32Windows,
+    withNoWarning,
 )
 
 _warned_unused_plugins = set()
@@ -94,6 +111,131 @@ _package_versions = {}
 # "getEvaluationConditionControlTags" value.
 control_tags = {}
 
+_context_dict = None
+
+# Populated when "constants" and "variables" yaml sections get evaluated.
+_module_config_constants = {}
+_module_config_variables = {}
+
+
+def _getImportLibModule():
+    try:
+        import importlib
+    except ImportError:
+        return None
+    else:
+        return importlib
+
+
+def _makeEvaluationContext(logger, full_name, config_name):
+    context = TagContext(logger=logger, full_name=full_name, config_name=config_name)
+    context.update(control_tags)
+
+    context.update(_getEvaluationContext())
+
+    return context
+
+
+def _getEvaluationContext():
+    # Using global here, as this is really a singleton, in the form of a module,
+    # pylint: disable=global-statement
+    global _context_dict
+
+    if _context_dict is None:
+        _context_dict = {
+            "macos": isMacOS(),
+            "win32": isWin32Windows(),
+            "linux": isLinux(),
+            "android": isAndroidBasedLinux(),
+            "android32": isAndroidBasedLinux() and sys.maxsize < 2**32,
+            "android64": isAndroidBasedLinux() and sys.maxsize >= 2**64 - 1,
+            "anaconda": isAnacondaPython(),
+            "is_conda_package": isDistributionCondaPackage,
+            "debian_python": isDebianPackagePython(),
+            "nuitka_python": isNuitkaPython(),
+            "standalone": isStandaloneMode(),
+            "onefile": isOnefileMode(),
+            "onefile_cached": not isOnefileTempDirMode(),
+            "module_mode": shallMakeModule(),
+            "deployment": isDeploymentMode(),
+            # Version information
+            "company": getCompanyName(),
+            "product": getProductName(),
+            "file_version": getFileVersion(),
+            "product_version": getProductVersion(),
+            "combined_version": getProductFileVersion(),
+            # Querying package versions.
+            "version": _getPackageVersion,
+            "version_str": _getPackageVersionStr,
+            "get_dist_name": _getDistributionNameFromPackageName,
+            "plugin": _isPluginActive,
+            # Iterating packages
+            "iterate_modules": _iterate_module_names,
+            # Locating package directories
+            "get_module_directory": _getModuleDirectory,
+            # Checking module presence
+            "has_module": _hasModule,
+            # Getting data files contents
+            "get_data": _getPackageData,
+            # Querying package properties
+            "has_builtin_module": isBuiltinModuleName,
+            # Architectures
+            "arch_x86": getArchitecture() == "x86",
+            "arch_amd64": getArchitecture() == "x86_64",
+            "arch_arm64": getArchitecture() == "arm64",
+            # Frequent used modules
+            "sys": sys,
+            "os": os,
+            "importlib": _getImportLibModule(),
+            "appdirs": getAppdirsModule(),
+            "unittest": unittest,
+            # Python version string
+            "python_version_str": python_version_str,
+            "python_version_full_str": python_version_full_str,
+            # Technical requirements
+            "static_libpython": getSystemStaticLibPythonPath() is not None,
+            # Builtins
+            "True": True,
+            "False": False,
+            "None": None,
+            "repr": repr,
+            "len": len,
+            "str": str,
+            "bool": bool,
+            "int": int,
+            "tuple": tuple,
+            "list": list,
+            "dict": dict,
+            "set": set,
+            "getattr": getattr,
+            "hasattr": hasattr,
+            "frozenset": frozenset,
+            "__import__": __import__,
+        }
+
+        versions = getTestExecutionPythonVersions()
+
+        for version in versions:
+            big, major = version.split(".")
+            numeric_version = int(big) * 256 + int(major) * 16
+            is_same_or_higher_version = python_version >= numeric_version
+
+            _context_dict["python" + big + major + "_or_higher"] = (
+                is_same_or_higher_version
+            )
+            _context_dict["before_python" + big + major] = not is_same_or_higher_version
+
+        _context_dict["before_python3"] = python_version < 0x300
+        _context_dict["python3_or_higher"] = python_version >= 0x300
+
+        if not isNuitkaPython():
+            _context_dict["extension_std_suffix"] = getSharedLibrarySuffix(
+                preferred=True
+            )
+            _context_dict["extension_suffix"] = getSharedLibrarySuffix(preferred=False)
+
+    return _context_dict
+
 
 def _convertVersionToTuple(version_str):
     def numberize(v):
@@ -104,6 +246,8 @@ def _convertVersionToTuple(version_str):
 
 
 def _getPackageNameFromDistributionName(distribution_name):
+    # spell-checker: ignore opencv, pyobjc, objc
+
     if distribution_name in ("opencv-python", "opencv-python-headless"):
         return "cv2"
     elif distribution_name == "pyobjc":
@@ -112,6 +256,16 @@ def _getPackageNameFromDistributionName(distribution_name):
         return distribution_name
 
 
+def _getDistributionNameFromPackageName(package_name):
+    package_name = ModuleName(package_name)
+    distribution = getDistributionFromModuleName(package_name)
+
+    if distribution is None:
+        return package_name.asString()
+    else:
+        return getDistributionName(distribution)
+
+
 def _getPackageVersion(distribution_name):
     if distribution_name not in _package_versions:
         try:
@@ -157,13 +311,64 @@ def _getPackageVersion(distribution_name):
     return _package_versions[distribution_name]
 
 
+def _getPackageVersionStr(distribution_name):
+    version = _getPackageVersion(distribution_name)
+
+    if version is not None:
+        version = ".".join(str(d) for d in version)
+
+    return version
+
+
+def _getModuleDirectory(module_name):
+    from nuitka.importing.Importing import locateModule
+
+    _module_name, module_filename, _module_kind, _finding = locateModule(
+        module_name=ModuleName(module_name), parent_package=None, level=0
+    )
+
+    return module_filename
+
+
+def _hasModule(module_name):
+    from nuitka.importing.Importing import locateModule
+
+    _module_name, _module_filename, _module_kind, finding = locateModule(
+        module_name=ModuleName(module_name), parent_package=None, level=0
+    )
+
+    return finding != "not-found"
+
+
+def _getPackageData(package_name, resource):
+    from nuitka.utils.PackageResources import getPackageData
+
+    return getPackageData(package_name=ModuleName(package_name), resource=resource)
+
+
+def _iterate_module_names(package_name):
+    package_name = ModuleName(package_name)
+    package_path = _getModuleDirectory(module_name=package_name)
+
+    result = []
+
+    for module_info in iter_modules([package_path]):
+        module_name = package_name.getChildNamed(module_info.name)
+        result.append(module_name.asString())
+
+        if module_info.ispkg:  # spell-checker: ignore ispkg
+            result.extend(_iterate_module_names(package_name=module_name))
+
+    return result
+
+
 def _isPluginActive(plugin_name):
     from .Plugins import getUserActivatedPluginNames
 
     return plugin_name in getUserActivatedPluginNames()
 
 
-class NuitkaPluginBase(getMetaClassBase("Plugin")):
+class NuitkaPluginBase(getMetaClassBase("Plugin", require_slots=False)):
     """Nuitka base class for all plugins.
 
     Derive your plugin from "NuitkaPluginBase" please.
@@ -273,7 +478,7 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
         # Virtual method, pylint: disable=no-self-use,unused-argument
         return ()
 
-    def onModuleSourceCode(self, module_name, source_code):
+    def onModuleSourceCode(self, module_name, source_filename, source_code):
         """Inspect or modify source code.
 
         Args:
@@ -286,6 +491,7 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
             going to allow simply checking the source code without the need to
             pass it back.
         """
+        # Virtual method, pylint: disable=unused-argument
         self.checkModuleSourceCode(module_name, source_code)
 
         return source_code
@@ -431,6 +637,25 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
         # Virtual method, pylint: disable=no-self-use,unused-argument
         return None
 
+    def onModuleUsageLookAhead(
+        self, module_name, module_filename, module_kind, get_module_source
+    ):
+        """React to tentative recursion of a module coming up.
+
+        For definite usage, use onModuleRecursion where it's a fact and
+        happening next. This may be a usage that is later optimized away
+        and doesn't impact anything. The main usage is to setup e.g.
+        hard imports as a factory, e.g. with detectable lazy loaders.
+
+        Args:
+            module_name: full module name
+            module_filename: filename
+            module_kind: one of "py", "extension" (shared library)
+            get_module_source: callable to get module source code if any
+        Returns:
+            None
+        """
+
     def onModuleRecursion(
         self,
         module_name,
@@ -440,7 +665,7 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
         source_ref,
         reason,
     ):
-        """React to recursion to a module coming up.
+        """React to recursion of a module coming up.
 
         Args:
             module_name: full module name
@@ -555,22 +780,28 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
         """
         return locateDLLsInDirectory(directory)
 
-    def makeDllEntryPoint(self, source_path, dest_path, package_name, reason):
+    def makeDllEntryPoint(
+        self, source_path, dest_path, module_name, package_name, reason
+    ):
         """Create an entry point, as expected to be provided by getExtraDlls."""
         return makeDllEntryPoint(
             logger=self,
             source_path=source_path,
             dest_path=dest_path,
+            module_name=module_name,
             package_name=package_name,
             reason=reason,
         )
 
-    def makeExeEntryPoint(self, source_path, dest_path, package_name, reason):
+    def makeExeEntryPoint(
+        self, source_path, dest_path, module_name, package_name, reason
+    ):
         """Create an entry point, as expected to be provided by getExtraDlls."""
         return makeExeEntryPoint(
             logger=self,
             source_path=source_path,
             dest_path=dest_path,
+            module_name=module_name,
             package_name=package_name,
             reason=reason,
         )
@@ -716,6 +947,7 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
         ignore_suffixes=(),
         only_suffixes=(),
         normalize=True,
+        raw=False,
     ):
         return makeIncludedDataDirectory(
             source_path=source_path,
@@ -728,6 +960,7 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
             ignore_suffixes=ignore_suffixes,
             only_suffixes=only_suffixes,
             normalize=normalize,
+            raw=raw,
         )
 
     def makeIncludedEmptyDirectory(self, dest_path, reason, tags):
@@ -866,6 +1099,18 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
         # Virtual method, pylint: disable=no-self-use,unused-argument
         return None
 
+    def decideAnnotations(self, module_name):
+        # Virtual method, pylint: disable=no-self-use,unused-argument
+        return None
+
+    def decideDocStrings(self, module_name):
+        # Virtual method, pylint: disable=no-self-use,unused-argument
+        return None
+
+    def decideAssertions(self, module_name):
+        # Virtual method, pylint: disable=no-self-use,unused-argument
+        return None
+
     def getPreprocessorSymbols(self):
         """Decide which C defines to be used in compilation.
 
@@ -904,6 +1149,21 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
         # Virtual method, pylint: disable=no-self-use
         return None
 
+    @classmethod
+    def getPluginDataFilesDir(cls):
+        """Helper function that returns path, where data files for the plugin are stored."""
+        plugin_filename = sys.modules[cls.__module__].__file__
+        return changeFilenameExtension(plugin_filename, "")
+
+    def getPluginDataFileContents(self, filename):
+        """Helper function that returns contents of a plugin data file."""
+        return getFileContents(
+            os.path.join(
+                self.getPluginDataFilesDir(),
+                filename,
+            )
+        )
+
     def getExtraCodeFiles(self):
         """Add extra code files to the compilation.
 
@@ -992,7 +1252,8 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
     _runtime_information_cache = {}
 
     def queryRuntimeInformationMultiple(self, info_name, setup_codes, values):
-        info_name = self.plugin_name.replace("-", "_") + "_" + info_name
+        info_name = self.plugin_name + "_" + info_name
+        info_name = info_name.replace("-", "_").replace(".", "_")
 
         if info_name in self._runtime_information_cache:
             return self._runtime_information_cache[info_name]
@@ -1010,31 +1271,52 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
             setup_codes = setup_codes.splitlines()
 
         if not setup_codes:
-            setup_codes = ["pass"]
+            setup_codes = ("pass",)
 
         cmd = r"""\
 from __future__ import print_function
 from __future__ import absolute_import
+import sys
 
 try:
 %(setup_codes)s
 except ImportError:
-    import sys
     sys.exit(38)
+try:
 %(query_codes)s
+except Exception as e:
+    sys.stderr.write("\n%%s" %% repr(e))
+    sys.exit(39)
 """ % {
             "setup_codes": "\n".join("   %s" % line for line in setup_codes),
-            "query_codes": "\n".join(query_codes),
+            "query_codes": "\n".join("   %s" % line for line in query_codes),
         }
 
         if shallShowExecutedCommands():
-            self.info("Executing query command:\n%s" % cmd)
+            self.info("Executing query command:\n%s" % cmd, keep_format=True)
+
+        env = dict(os.environ)
+        env["PYTHONIOENCODING"] = "utf8"
 
         try:
-            feedback = check_output([sys.executable, "-c", cmd])
+            feedback = check_output([sys.executable, "-c", cmd], env=env)
         except NuitkaCalledProcessError as e:
             if e.returncode == 38:
                 return None
+
+            if Options.is_debug:
+                self.info(cmd, keep_format=True)
+
+            if e.returncode == 39:
+                # TODO: Recognize the ModuleNotFoundError or ImportError exceptions
+                # and output the missing module.
+                self.warning(
+                    "Exception during compile time command execution: %s"
+                    % e.stderr.splitlines()[-1]
+                )
+
+                return None
+
             raise
 
         if str is not bytes:  # We want to work with strings, that's hopefully OK.
@@ -1079,6 +1361,14 @@ except ImportError:
         # Virtual method, pylint: disable=no-self-use,unused-argument
         return False
 
+    def onClassBodyParsing(self, module_name, class_name, node):
+        # Virtual method, pylint: disable=no-self-use,unused-argument
+        """Provide a different class body for the class of that module.
+
+        Should return a boolean, indicating if any actual change was done.
+        """
+        return False
+
     def getCacheContributionValues(self, module_name):
         """Provide values that represent the include of a plugin on the compilation.
 
@@ -1090,6 +1380,11 @@ except ImportError:
         # Virtual method, pylint: disable=unused-argument
         return self.plugin_name
 
+    def getExtraConstantDefaultPopulation(self):
+        """Provide extra global constant values to code generation."""
+        # Virtual method, pylint: disable=no-self-use
+        return ()
+
     def decideAllowOutsideDependencies(self, module_name):
         """Decide if outside of Python dependencies are allowed.
 
@@ -1100,14 +1395,226 @@ except ImportError:
         return None
 
     @staticmethod
-    def getPackageVersion(distribution_name):
+    def getPackageVersion(module_name):
         """Provide package version of a distribution."""
+        distribution_name = _getDistributionNameFromPackageName(module_name)
+
         return _getPackageVersion(distribution_name)
 
     def getEvaluationConditionControlTags(self):
         # Virtual method, pylint: disable=no-self-use
         return {}
 
+    @staticmethod
+    def isValueForEvaluation(expression):
+        return '"' in expression or "'" in expression or "(" in expression
+
+    def evaluateExpressionOrConstant(
+        self, full_name, expression, config_name, extra_context, single_value
+    ):
+        if self.isValueForEvaluation(expression):
+            return self.evaluateExpression(
+                full_name=full_name,
+                expression=expression,
+                config_name=config_name,
+                extra_context=extra_context,
+                single_value=single_value,
+            )
+        else:
+            return expression
+
+    def getExpressionConstants(self, full_name):
+        if full_name not in _module_config_constants:
+            constants = {}
+
+            for count, constant_config in enumerate(
+                self.config.get(full_name, section="constants"), start=1
+            ):
+                declarations = constant_config.get("declarations")
+
+                if declarations and self.evaluateCondition(
+                    full_name=full_name,
+                    condition=constant_config.get("when", "True"),
+                ):
+                    for constant_name, constant_value in declarations.items():
+                        constants[constant_name] = self.evaluateExpressionOrConstant(
+                            full_name=full_name,
+                            expression=constant_value,
+                            config_name="constants config #%d" % count,
+                            extra_context=None,
+                            single_value=False,
+                        )
+
+            _module_config_constants[full_name] = constants
+
+        return _module_config_constants[full_name]
+
+    def getExpressionVariables(self, full_name):
+        if full_name not in _module_config_variables:
+            variables = {}
+
+            for count, variable_config in enumerate(
+                self.config.get(full_name, section="variables")
+            ):
+                environment = variable_config.get("environment", {})
+                setup_codes = variable_config.get("setup_code", [])
+                if type(setup_codes) is str:
+                    setup_codes = setup_codes.splitlines()
+                declarations = variable_config.get("declarations", {})
+
+                if len(declarations) < 1:
+                    self.sysexit(
+                        "Error, no variable 'declarations' for %s makes no sense."
+                        % full_name
+                    )
+
+                if self.evaluateCondition(
+                    full_name=full_name,
+                    condition=variable_config.get("when", "True"),
+                ):
+                    setup_codes.extend(
+                        "%s=%r" % (constant_name, constant_value)
+                        for (
+                            constant_name,
+                            constant_value,
+                        ) in self.getExpressionConstants(full_name=full_name).items()
+                    )
+
+                    env_variables = {}
+
+                    for env_name, env_value in environment.items():
+                        env_variables[env_name] = self.evaluateExpressionOrConstant(
+                            full_name=full_name,
+                            expression=env_value,
+                            config_name="variables config #%d" % count,
+                            extra_context=None,
+                            single_value=True,
+                        )
+
+                    with withEnvironmentVarsOverridden(env_variables):
+                        info = self.queryRuntimeInformationMultiple(
+                            "%s_variables_%s" % (full_name.asString(), count),
+                            setup_codes=setup_codes,
+                            values=tuple(declarations.items()),
+                        )
+
+                    if Options.isExperimental("display-yaml-variables"):
+                        self.info("Evaluated %r" % info)
+
+                    if info is None:
+                        self.sysexit(
+                            "Error, failed to evaluate variables for '%s'." % full_name
+                        )
+
+                    variables.update(info.asDict())
+
+            _module_config_variables[full_name] = variables
+
+        return _module_config_variables[full_name]
+
+    def evaluateExpression(
+        self, full_name, expression, config_name, extra_context, single_value
+    ):
+        context = _makeEvaluationContext(
+            logger=self, full_name=full_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]
+
+            addModuleInfluencingVariable(
+                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
+
+        context["get_variable"] = get_variable
+        context["get_constant"] = get_constant
+
+        def get_parameter(parameter_name, default):
+            result = Options.getModuleParameter(full_name, parameter_name)
+
+            if result is None:
+                result = default
+
+            self.addModuleInfluencingParameter(
+                module_name=full_name,
+                parameter_name=parameter_name,
+                condition_tags_used=context.used_tags,
+                result=result,
+            )
+
+            return result
+
+        context["get_parameter"] = get_parameter
+
+        if extra_context:
+            context.update(extra_context)
+
+        with withNoWarning():
+            # We trust the yaml files, pylint: disable=eval-used
+            try:
+                result = eval(expression, context)
+            except Exception as e:  # Catch all the things, pylint: disable=broad-except
+                if Options.is_debug:
+                    raise
+
+                self.sysexit(
+                    "Error, failed to evaluate expression %r in this context, exception was '%r'."
+                    % (expression, e)
+                )
+
+        if type(result) not in (str, unicode):
+            if single_value:
+                self._checkStrResult(
+                    value=result, expression=expression, full_name=full_name
+                )
+            else:
+                self._checkSequenceResult(
+                    value=result, expression=expression, full_name=full_name
+                )
+
+                for v in result:
+                    self._checkStrResult(
+                        value=v, expression=expression, full_name=full_name
+                    )
+
+                # Make it immutable in case it's a list.
+                result = tuple(result)
+
+        return result
+
+    def _checkStrResult(self, value, expression, full_name):
+        if type(value) not in (str, unicode):
+            self.sysexit(
+                """\
+Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' or 'list[str]' result but '%s'"""
+                % (expression, full_name, type(value))
+            )
+
+    def _checkSequenceResult(self, value, expression, full_name):
+        if type(value) not in (tuple, list):
+            self.sysexit(
+                """\
+Error, expression '%s' for module '%s' did not evaluate to 'tuple[str]' or 'list[str]' result."""
+                % (expression, full_name)
+            )
+
     def evaluateCondition(self, full_name, condition):
         # Note: Caching makes no sense yet, this should all be very fast and
         # cache themselves. TODO: Allow plugins to contribute their own control
@@ -1117,64 +1624,40 @@ except ImportError:
         if condition == "False":
             return False
 
-        context = TagContext(logger=self, full_name=full_name)
-        context.update(control_tags)
-
-        context.update(
-            {
-                "macos": isMacOS(),
-                "win32": isWin32Windows(),
-                "linux": isLinux(),
-                "anaconda": isAnacondaPython(),
-                "is_conda_package": isDistributionCondaPackage,
-                "debian_python": isDebianPackagePython(),
-                "standalone": isStandaloneMode(),
-                "module_mode": shallMakeModule(),
-                "deployment": isDeploymentMode(),
-                # Querying package versions.
-                "version": _getPackageVersion,
-                "plugin": _isPluginActive,
-                "no_asserts": hasPythonFlagNoAsserts(),
-                "no_docstrings": hasPythonFlagNoDocStrings(),
-                "no_annotations": hasPythonFlagNoAnnotations(),
-                # Querying package properties
-                "has_builtin_module": isBuiltinModuleName,
-            }
+        # TODO: Maybe add module name to config name?
+        context = _makeEvaluationContext(
+            logger=self, full_name=full_name, config_name="'when' configuration"
         )
 
-        if isWin32Windows():
-            context.update(
-                {
-                    "arch_x86": getArchitecture() == "x86",
-                    "arch_amd64": getArchitecture() == "x86_64",
-                    "arch_arm64": getArchitecture() == "arm64",
-                }
-            )
+        def get_parameter(parameter_name, default):
+            result = Options.getModuleParameter(full_name, parameter_name)
 
-        versions = getTestExecutionPythonVersions()
+            if result is None:
+                result = default
 
-        for version in versions:
-            big, major = version.split(".")
-            numeric_version = int(big) * 256 + int(major) * 16
-            is_same_or_higher_version = python_version >= numeric_version
-
-            context["python" + big + major + "_or_higher"] = is_same_or_higher_version
-            context["before_python" + big + major] = not is_same_or_higher_version
+            self.addModuleInfluencingParameter(
+                module_name=full_name,
+                parameter_name=parameter_name,
+                condition_tags_used=context.used_tags,
+                result=result,
+            )
 
-        context["before_python3"] = python_version < 0x300
-        context["python3_or_higher"] = python_version >= 0x300
+            return result
 
-        # We trust the yaml files, pylint: disable=eval-used
-        try:
-            result = eval(condition, context)
-        except Exception as e:  # Catch all the things, pylint: disable=broad-except
-            if Options.is_debug:
-                raise
+        context["get_parameter"] = get_parameter
 
-            self.sysexit(
-                "Error, failed to evaluate condition '%s' in this context, exception was '%s'."
-                % (condition, e)
-            )
+        with withNoWarning():
+            # We trust the yaml files, pylint: disable=eval-used
+            try:
+                result = eval(condition, context)
+            except Exception as e:  # Catch all the things, pylint: disable=broad-except
+                if Options.is_debug:
+                    raise
+
+                self.sysexit(
+                    "Error, failed to evaluate condition '%s' in this context, exception was '%s'."
+                    % (condition, e)
+                )
 
         if type(result) is not bool:
             self.sysexit(
@@ -1192,6 +1675,27 @@ except ImportError:
 
         return result
 
+    def addModuleInfluencingParameter(
+        self, module_name, parameter_name, condition_tags_used, result
+    ):
+        addModuleInfluencingParameter(
+            module_name=module_name,
+            plugin_name=self.plugin_name,
+            parameter_name=parameter_name,
+            condition_tags_used=condition_tags_used,
+            result=result,
+        )
+
+    def addModuleInfluencingDetection(
+        self, module_name, detection_name, detection_value
+    ):
+        addModuleInfluencingDetection(
+            module_name=module_name,
+            plugin_name=self.plugin_name,
+            detection_name=detection_name,
+            detection_value=detection_value,
+        )
+
     @classmethod
     def warning(cls, message, **kwargs):
         # Doing keyword only arguments manually, to keep older Python compatibility, and avoid
@@ -1203,40 +1707,31 @@ except ImportError:
         plugins_logger.warning(cls.plugin_name + ": " + message, mnemonic=mnemonic)
 
     @classmethod
-    def info(cls, message):
-        plugins_logger.info(cls.plugin_name + ": " + message)
+    def info(cls, message, keep_format=False):
+        plugins_logger.info(message, prefix=cls.plugin_name, keep_format=keep_format)
+
+    @classmethod
+    def debug(cls, message, keep_format=False):
+        if Options.is_debug:
+            cls.info(message, keep_format=keep_format)
 
     @classmethod
-    def sysexit(cls, message, mnemonic=None):
+    def sysexit(cls, message, mnemonic=None, reporting=True):
         plugins_logger.sysexit(
-            cls.plugin_name + ": " + message, mnemonic=mnemonic, reporting=True
+            cls.plugin_name + ": " + message, mnemonic=mnemonic, reporting=reporting
         )
 
 
-def standalone_only(func):
-    """For plugins that have functionality that should be done in standalone mode only."""
-
-    @functools.wraps(func)
-    def wrapped(*args, **kwargs):
-        if isStandaloneMode():
-            return func(*args, **kwargs)
-        else:
-            if inspect.isgeneratorfunction(func):
-                return ()
-            else:
-                return None
-
-    return wrapped
-
-
 class TagContext(dict):
-    def __init__(self, logger, full_name, *args, **kwargs):
-        dict.__init__(self, *args, **kwargs)
+    def __init__(self, logger, full_name, config_name):
+        dict.__init__(self)
 
         self.logger = logger
         self.full_name = full_name
+        self.config_name = config_name
 
         self.used_tags = OrderedSet()
+        self.used_variables = OrderedSet()
 
     def __getitem__(self, key):
         try:
@@ -1247,7 +1742,55 @@ class TagContext(dict):
             if key.startswith("use_"):
                 return False
 
+            if key == "no_asserts":
+                # TODO: This should be better decoupled.
+                from .Plugins import Plugins
+
+                return Plugins.decideAssertions(self.full_name) is False
+
+            if key == "no_docstrings":
+                from .Plugins import Plugins
+
+                return Plugins.decideDocStrings(self.full_name) is False
+
+            if key == "no_annotations":
+                from .Plugins import Plugins
+
+                return Plugins.decideAnnotations(self.full_name) is False
+
             self.logger.sysexit(
-                "Identifier '%s' in 'when' configuration of module '%s' is unknown."
-                % (key, self.full_name)
+                "Identifier '%s' in %s of module '%s' is unknown."
+                % (key, self.config_name, self.full_name)
             )
+
+
+def standalone_only(func):
+    """For plugins that have functionality that should be done in standalone mode only."""
+
+    @functools.wraps(func)
+    def wrapped(*args, **kwargs):
+        if isStandaloneMode():
+            return func(*args, **kwargs)
+        else:
+            if inspect.isgeneratorfunction(func):
+                return ()
+            else:
+                return None
+
+    return wrapped
+
+
+#     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.