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

nuitka/nodes/VariableAssignNodes.py

@@ -798,7 +798,7 @@ class StatementAssignmentVariableConstantMutableTrusted(
 
     @staticmethod
     def hasVeryTrustedValue():
-        return True
+        return False
 
 
 class StatementAssignmentVariableConstantImmutableTrusted(

nuitka/nodes/VariableRefNodes.py

@@ -318,6 +318,23 @@ Subscript del to dictionary lowered to dictionary del."""
 Subscript look-up to dictionary lowered to dictionary look-up.""",
             )
 
+        if subscript.isCompileTimeConstant():
+            attribute_node = self.variable_trace.getAttributeNode()
+
+            if attribute_node is not None:
+                # TODO: That could probably be one single question.
+                if (
+                    attribute_node.isCompileTimeConstant()
+                    and not attribute_node.isMutable()
+                ):
+                    return trace_collection.getCompileTimeComputationResult(
+                        node=lookup_node,
+                        computation=lambda: attribute_node.getCompileTimeConstant()[
+                            subscript.getCompileTimeConstant()
+                        ],
+                        description="Subscript of variable immutable value.",
+                    )
+
         # Any code could be run, note that.
         trace_collection.onControlFlowEscape(self)
 
@@ -420,6 +437,15 @@ class ExpressionVariableRef(ExpressionVariableRefBase):
             # could be decided from context.
             trace_collection.onExceptionRaiseExit(BaseException)
 
+        very_trusted_node = self.variable_trace.getAttributeNodeVeryTrusted()
+        if very_trusted_node is not None:
+            return (
+                very_trusted_node.makeClone(),
+                "new_expression",
+                lambda: "Forward propagating value of %s from very trusted %s value."
+                % (self.getVariableName(), very_trusted_node.kind),
+            )
+
         if variable.isModuleVariable() and (
             variable.hasDefiniteWrites() is False or variable.getName() == "super"
         ):
@@ -494,7 +520,7 @@ Replaced read-only module attribute '__package__' with module attribute referenc
                 change_tags = "new_expression"
                 change_desc = """\
 Replaced read-only module attribute '__loader__' with module attribute reference."""
-            elif variable_name == "__spec__" and python_version >= 0x340:
+            elif variable_name == "__spec__" and python_version >= 0x300:
                 new_node = ExpressionModuleAttributeSpecRef(
                     variable=variable, source_ref=self.source_ref
                 )
@@ -586,7 +612,7 @@ Replaced read-only module attribute '__spec__' with module attribute reference."
                     return (
                         bool(attribute_node.getCompileTimeConstant()),
                         attribute_node.makeClone(),
-                        "Using very trusted constant truth value.",
+                        "Using trusted constant's truth value.",
                     )
 
         # TODO: This is probably only default stuff here, that could be compressed.

nuitka/optimizations/FunctionInlining.py

@@ -9,10 +9,9 @@ from the in-lined function.
 
 from nuitka.nodes.OutlineNodes import ExpressionOutlineBody
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
-from nuitka.nodes.VariableReleaseNodes import makeStatementsReleaseVariables
 from nuitka.tree.Operations import VisitorNoopMixin, visitTree
 from nuitka.tree.ReformulationTryFinallyStatements import (
-    makeTryFinallyStatement,
+    makeTryFinallyReleaseStatement,
 )
 from nuitka.tree.TreeHelpers import makeStatementsSequence
 
@@ -83,12 +82,10 @@ def convertFunctionCallToOutline(provider, function_body, values, call_source_re
 
     # TODO: Not possible to auto release with outline bodies too?
     if auto_releases:
-        body = makeTryFinallyStatement(
+        body = makeTryFinallyReleaseStatement(
             provider=outline_body,
             tried=body,
-            final=makeStatementsReleaseVariables(
-                variables=auto_releases, source_ref=function_source_ref
-            ),
+            variables=auto_releases,
             source_ref=function_source_ref,
         )
 

nuitka/optimizations/Optimization.py

@@ -26,7 +26,7 @@ from nuitka.utils.Timing import TimerReport
 from . import Graphs
 from .BytecodeDemotion import demoteCompiledModuleToBytecode
 from .Tags import TagSet
-from .TraceCollections import withChangeIndicationsTo
+from .TraceCollections import fetchMergeCounts, withChangeIndicationsTo
 
 tag_set = None
 
@@ -68,7 +68,12 @@ def optimizeCompiledPythonModule(module):
     # allow to continue the loop even without changes one more time.
     unchanged_count = 0
 
+    # Count the micro passes, so we can see how often we looped
+    micro_pass = 0
+
     while True:
+        micro_pass += 1
+
         tag_set.clear()
 
         try:
@@ -120,7 +125,7 @@ def optimizeCompiledPythonModule(module):
 
     considerUsedModules(module=module, pass_count=pass_count)
 
-    return touched
+    return touched, micro_pass
 
 
 def optimizeUncompiledPythonModule(module):
@@ -156,14 +161,12 @@ def optimizeModule(module):
 
     if module.isPythonExtensionModule():
         optimizeExtensionModule(module)
-        changed = False
+        return False, 0
     elif module.isCompiledPythonModule():
-        changed = optimizeCompiledPythonModule(module)
+        return optimizeCompiledPythonModule(module)
     else:
         optimizeUncompiledPythonModule(module)
-        changed = False
-
-    return changed
+        return False, 0
 
 
 pass_count = 0
@@ -250,8 +253,6 @@ def restoreFromXML(text):
 def makeOptimizationPass():
     """Make a single pass for optimization, indication potential completion."""
 
-    # Controls complex optimization
-
     finished = True
 
     ModuleRegistry.startTraversal()
@@ -284,14 +285,14 @@ def makeOptimizationPass():
         with TimerReport(
             message="Optimizing %s" % module_name, decider=False
         ) as module_timer:
-            changed = optimizeModule(current_module)
-
-            # module_timer=module_time_report.getTimer()
+            changed, micro_passes = optimizeModule(current_module)
 
         ModuleRegistry.addModuleOptimizationTimeInformation(
             module_name=module_name,
             pass_number=pass_count,
             time_used=module_timer.getDelta(),
+            micro_passes=micro_passes,
+            merge_counts=fetchMergeCounts(),
         )
 
         _traceProgressModuleEnd(current_module)

nuitka/optimizations/TraceCollections.py

@@ -51,6 +51,16 @@ from .ValueTraces import (
     ValueTraceUnknown,
 )
 
+# Keeping trace of how often branches are merged between calls
+_merge_counts = defaultdict(int)
+
+
+def fetchMergeCounts():
+    result = dict(_merge_counts)
+    _merge_counts.clear()
+    return result
+
+
 signalChange = None
 
 
@@ -189,10 +199,10 @@ class CollectionStartPointMixin(CollectionUpdateMixin):
 
         # TODO: We might want to track per exception, pylint: disable=unused-argument
 
-        if collection is None:
-            collection = self
-
         if self.exception_collections is not None:
+            if collection is None:
+                collection = self
+
             self.exception_collections.append(
                 TraceCollectionBranch(parent=collection, name="exception")
             )
@@ -754,6 +764,8 @@ class TraceCollectionBase(object):
             collection1 = collection_yes
             collection2 = collection_no
 
+        _merge_counts[2] += 1
+
         variable_versions = {}
 
         for variable, version in iterItems(collection1.variable_actives):
@@ -816,7 +828,8 @@ class TraceCollectionBase(object):
         elif merge_size == 2:
             return self.mergeBranches(*collections)
 
-        # print("Enter mergeMultipleBranches", len(collections))
+        _merge_counts[len(collections)] += 1
+
         with TimerReport(
             message="Running merge for %s took %%.2f seconds" % collections,
             decider=False,
@@ -874,6 +887,8 @@ class TraceCollectionBase(object):
         self.variable_actives.update(collection_replace.variable_actives)
         collection_replace.variable_actives = None
 
+        _merge_counts[1] += 1
+
     def onLoopBreak(self, collection=None):
         if collection is None:
             collection = self

nuitka/plugins/PluginBase.py

@@ -43,10 +43,14 @@ from nuitka.ModuleRegistry import (
     getModuleInclusionInfoByName,
 )
 from nuitka.Options import (
-    hasPythonFlagNoAnnotations,
-    hasPythonFlagNoAsserts,
-    hasPythonFlagNoDocStrings,
+    getCompanyName,
+    getFileVersion,
+    getProductFileVersion,
+    getProductName,
+    getProductVersion,
     isDeploymentMode,
+    isOnefileMode,
+    isOnefileTempDirMode,
     isStandaloneMode,
     shallCreateAppBundle,
     shallMakeModule,
@@ -70,7 +74,11 @@ from nuitka.utils.Distributions import (
     getDistributionName,
     isDistributionCondaPackage,
 )
-from nuitka.utils.Execution import NuitkaCalledProcessError, check_output
+from nuitka.utils.Execution import (
+    NuitkaCalledProcessError,
+    check_output,
+    withEnvironmentVarsOverridden,
+)
 from nuitka.utils.FileOperations import (
     changeFilenameExtension,
     getFileContents,
@@ -84,6 +92,7 @@ from nuitka.utils.ModuleNames import (
 )
 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,
@@ -92,7 +101,6 @@ from nuitka.utils.Utils import (
     isWin32Windows,
     withNoWarning,
 )
-from nuitka.utils.Yaml import getYamlPackageConfiguration
 
 _warned_unused_plugins = set()
 
@@ -119,6 +127,15 @@ def _getImportLibModule():
         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
@@ -137,16 +154,21 @@ def _getEvaluationContext():
             "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,
-            "no_asserts": hasPythonFlagNoAsserts(),
-            "no_docstrings": hasPythonFlagNoDocStrings(),
-            "no_annotations": hasPythonFlagNoAnnotations(),
             # Iterating packages
             "iterate_modules": _iterate_module_names,
             # Locating package directories
@@ -166,6 +188,8 @@ def _getEvaluationContext():
             # 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,
@@ -1055,6 +1079,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 decideAsserts(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.
 
@@ -1245,7 +1281,7 @@ except ImportError:
                 return None
 
             if Options.is_debug:
-                self.info(cmd)
+                self.info(cmd, keep_format=True)
 
             raise
 
@@ -1386,16 +1422,22 @@ except ImportError:
             for count, variable_config in enumerate(
                 self.config.get(full_name, section="variables")
             ):
-                setup_codes = variable_config.get("setup_code")
-                declarations = variable_config.get("declarations")
+                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 declarations and self.evaluateCondition(
+                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"),
                 ):
-                    if type(setup_codes) is str:
-                        setup_codes = setup_codes.splitlines()
-
                     setup_codes.extend(
                         "%s=%r" % (constant_name, constant_value)
                         for (
@@ -1404,11 +1446,31 @@ except ImportError:
                         ) in self.getExpressionConstants(full_name=full_name).items()
                     )
 
-                    info = self.queryRuntimeInformationMultiple(
-                        "%s_variables_%s" % (full_name.asString(), count),
-                        setup_codes=setup_codes,
-                        values=tuple(declarations.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())
 
@@ -1419,10 +1481,9 @@ except ImportError:
     def evaluateExpression(
         self, full_name, expression, config_name, extra_context, single_value
     ):
-        context = TagContext(logger=self, full_name=full_name, config_name=config_name)
-        context.update(control_tags)
-
-        context.update(_getEvaluationContext())
+        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
@@ -1521,12 +1582,10 @@ Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' o
         if condition == "False":
             return False
 
-        context = TagContext(
+        # TODO: Maybe add module name to config name?
+        context = _makeEvaluationContext(
             logger=self, full_name=full_name, config_name="'when' configuration"
         )
-        context.update(control_tags)
-
-        context.update(_getEvaluationContext())
 
         def get_parameter(parameter_name, default):
             result = Options.getModuleParameter(full_name, parameter_name)
@@ -1609,6 +1668,11 @@ Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' o
     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, reporting=True):
         plugins_logger.sysexit(
@@ -1616,96 +1680,46 @@ Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' o
         )
 
 
-class NuitkaYamlPluginBase(NuitkaPluginBase):
-    """Nuitka base class for all plugins that use yaml config"""
-
-    def __init__(self):
-        self.config = getYamlPackageConfiguration()
-
-    def getYamlConfigItem(
-        self, module_name, section, item_name, decide_relevant, default, recursive
-    ):
-        while True:
-            module_configs = self.config.get(module_name, section=section)
-
-            if module_configs is not None:
-                for module_config in module_configs:
-                    config_item = module_config.get(item_name, default)
+class TagContext(dict):
+    def __init__(self, logger, full_name, config_name):
+        dict.__init__(self)
 
-                    # Avoid condition, if the item is not relevant
-                    if decide_relevant is not None and not decide_relevant(config_item):
-                        continue
+        self.logger = logger
+        self.full_name = full_name
+        self.config_name = config_name
 
-                    if not self.evaluateCondition(
-                        full_name=module_name,
-                        condition=module_config.get("when", "True"),
-                    ):
-                        continue
+        self.used_tags = OrderedSet()
+        self.used_variables = OrderedSet()
 
-                    if recursive:
-                        yield module_name, config_item
-                    else:
-                        yield config_item
+    def __getitem__(self, key):
+        try:
+            self.used_tags.add(key)
 
-            if not recursive:
-                break
+            return dict.__getitem__(self, key)
+        except KeyError:
+            if key.startswith("use_"):
+                return False
 
-            module_name = module_name.getPackageName()
-            if not module_name:
-                break
+            if key == "no_asserts":
+                # TODO: This should be better decoupled.
+                from .Plugins import Plugins
 
-    def getYamlConfigItemItems(
-        self, module_name, section, item_name, decide_relevant, recursive
-    ):
-        def dict_decide_relevant(item_dict):
-            if not item_dict:
-                return False
+                return Plugins.decideAssertions(self.full_name) is False
 
-            if decide_relevant is None:
-                return True
+            if key == "no_docstrings":
+                from .Plugins import Plugins
 
-            for key, value in item_dict.items():
-                if decide_relevant(key, value):
-                    return True
+                return Plugins.decideDocStrings(self.full_name) is False
 
-            return False
+            if key == "no_annotations":
+                from .Plugins import Plugins
 
-        for item_config in self.getYamlConfigItem(
-            module_name=module_name,
-            section=section,
-            item_name=item_name,
-            decide_relevant=dict_decide_relevant,
-            default={},
-            recursive=recursive,
-        ):
-            if recursive:
-                for key, value in item_config[1].items():
-                    if decide_relevant(key, value):
-                        yield item_config[0], key, value
-            else:
-                for key, value in item_config.items():
-                    if decide_relevant(key, value):
-                        yield key, value
+                return Plugins.decideAnnotations(self.full_name) is False
 
-    def getYamlConfigItemSet(
-        self, module_name, section, item_name, decide_relevant, recursive
-    ):
-        for item_config in self.getYamlConfigItem(
-            module_name=module_name,
-            section=section,
-            item_name=item_name,
-            decide_relevant=None,
-            default=(),
-            recursive=recursive,
-        ):
-            if recursive:
-                for value in item_config[1]:
-                    if decide_relevant is None or decide_relevant(value):
-                        yield item_config[0], value
-            else:
-                for value in item_config:
-                    if decide_relevant is None or decide_relevant(value):
-                        yield value
+            self.logger.sysexit(
+                "Identifier '%s' in %s of module '%s' is unknown."
+                % (key, self.config_name, self.full_name)
+            )
 
 
 def standalone_only(func):
@@ -1724,32 +1738,6 @@ def standalone_only(func):
     return wrapped
 
 
-class TagContext(dict):
-    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:
-            self.used_tags.add(key)
-
-            return dict.__getitem__(self, key)
-        except KeyError:
-            if key.startswith("use_"):
-                return False
-
-            self.logger.sysexit(
-                "Identifier '%s' in %s of module '%s' is unknown."
-                % (key, self.config_name, self.full_name)
-            )
-
-
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #