Nuitka-winsvc 1.8.6__cp312-cp312-win_amd64.whl → 1.9.3__cp312-cp312-win_amd64.whl

nuitka/tree/ReformulationWithStatements.py

@@ -49,7 +49,7 @@ from nuitka.nodes.StatementNodes import (
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
 from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
 from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
-from nuitka.nodes.YieldNodes import ExpressionYieldFromWaitable
+from nuitka.nodes.YieldNodes import ExpressionYieldFromAwaitable
 from nuitka.PythonVersions import python_version
 
 from .ReformulationAssignmentStatements import buildAssignmentStatements
@@ -75,13 +75,13 @@ def _buildWithNode(provider, context_expr, assign_target, body, sync, source_ref
     temp_scope = provider.allocateTempScope("with")
 
     tmp_source_variable = provider.allocateTempVariable(
-        temp_scope=temp_scope, name="source"
+        temp_scope=temp_scope, name="source", temp_type="object"
     )
     tmp_exit_variable = provider.allocateTempVariable(
-        temp_scope=temp_scope, name="exit"
+        temp_scope=temp_scope, name="exit", temp_type="object"
     )
     tmp_enter_variable = provider.allocateTempVariable(
-        temp_scope=temp_scope, name="enter"
+        temp_scope=temp_scope, name="enter", temp_type="object"
     )
 
     # Indicator variable, will end up with C bool type, and need not be released.
@@ -164,13 +164,13 @@ def _buildWithNode(provider, context_expr, assign_target, body, sync, source_ref
 
     # For "async with", await the entered value and exit value must be awaited.
     if not sync:
-        exit_value_exception = ExpressionYieldFromWaitable(
+        exit_value_exception = ExpressionYieldFromAwaitable(
             expression=ExpressionAsyncWaitExit(
                 expression=exit_value_exception, source_ref=source_ref
             ),
             source_ref=source_ref,
         )
-        exit_value_no_exception = ExpressionYieldFromWaitable(
+        exit_value_no_exception = ExpressionYieldFromAwaitable(
             ExpressionAsyncWaitExit(
                 expression=exit_value_no_exception, source_ref=source_ref
             ),
@@ -186,7 +186,7 @@ def _buildWithNode(provider, context_expr, assign_target, body, sync, source_ref
 
     # Before 3.9, __aenter__ is immediately awaited, after we first do __aexit__ lookup.
     if not sync and python_version < 0x390:
-        enter_value = ExpressionYieldFromWaitable(
+        enter_value = ExpressionYieldFromAwaitable(
             expression=ExpressionAsyncWaitEnter(
                 expression=enter_value, source_ref=source_ref
             ),
@@ -217,7 +217,7 @@ def _buildWithNode(provider, context_expr, assign_target, body, sync, source_ref
     if python_version >= 0x390 and not sync:
         enter_await_statement = makeStatementAssignmentVariable(
             variable=tmp_enter_variable,
-            source=ExpressionYieldFromWaitable(
+            source=ExpressionYieldFromAwaitable(
                 expression=ExpressionAsyncWaitEnter(
                     expression=ExpressionTempVariableRef(
                         variable=tmp_enter_variable, source_ref=source_ref

nuitka/tree/ReformulationYieldExpressions.py

@@ -29,7 +29,7 @@ from nuitka.nodes.CoroutineNodes import ExpressionAsyncWait
 from nuitka.nodes.YieldNodes import (
     ExpressionYield,
     ExpressionYieldFrom,
-    ExpressionYieldFromWaitable,
+    ExpressionYieldFromAwaitable,
 )
 from nuitka.PythonVersions import python_version
 
@@ -104,7 +104,7 @@ def buildYieldFromNode(provider, node, source_ref):
 def buildAwaitNode(provider, node, source_ref):
     _checkInsideGenerator("await", provider, node, source_ref)
 
-    return ExpressionYieldFromWaitable(
+    return ExpressionYieldFromAwaitable(
         expression=ExpressionAsyncWait(
             expression=buildNode(provider, node.value, source_ref),
             source_ref=source_ref,

nuitka/tree/SourceHandling.py

@@ -174,7 +174,20 @@ def getSourceCodeDiff(source_code, source_code_modified):
     return list(diff)
 
 
-def readSourceCodeFromFilenameWithInformation(module_name, source_filename):
+_source_code_cache = {}
+
+
+def readSourceCodeFromFilenameWithInformation(
+    module_name, source_filename, pre_load=False
+):
+    key = (module_name, source_filename)
+
+    if key in _source_code_cache:
+        if pre_load:
+            return _source_code_cache[key]
+        else:
+            return _source_code_cache.pop(key)
+
     if python_version < 0x300:
         source_code = _readSourceCodeFromFilename2(source_filename)
     else:
@@ -184,7 +197,9 @@ def readSourceCodeFromFilenameWithInformation(module_name, source_filename):
     # module and doesn't want any changes from plugins in that case.
     if module_name is not None:
         source_code_modified, contributing_plugins = Plugins.onModuleSourceCode(
-            module_name=module_name, source_code=source_code
+            module_name=module_name,
+            source_filename=source_filename,
+            source_code=source_code,
         )
     else:
         source_code_modified = source_code
@@ -198,12 +213,19 @@ def readSourceCodeFromFilenameWithInformation(module_name, source_filename):
             for line in source_diff:
                 my_print(line, end="\n" if not line.startswith("---") else "")
 
-    return source_code_modified, source_code, contributing_plugins
+    result = source_code_modified, source_code, contributing_plugins
+
+    if pre_load:
+        _source_code_cache[key] = result
+
+    return result
 
 
-def readSourceCodeFromFilename(module_name, source_filename):
+def readSourceCodeFromFilename(module_name, source_filename, pre_load=False):
     return readSourceCodeFromFilenameWithInformation(
-        module_name=module_name, source_filename=source_filename
+        module_name=module_name,
+        source_filename=source_filename,
+        pre_load=pre_load,
     )[0]
 
 

nuitka/tree/VariableClosure.py

@@ -162,7 +162,7 @@ class VariableClosureLookupVisitorPhase1(VisitorNoopMixin):
                     temp_scope = provider.allocateTempScope("class_inplace")
 
                     tmp_variable = provider.allocateTempVariable(
-                        temp_scope=temp_scope, name="value"
+                        temp_scope=temp_scope, name="value", temp_type="object"
                     )
 
                     statements = mergeStatements(
@@ -471,6 +471,16 @@ can not delete variable '%s' referenced in nested scope"""
                     while node != class_var.getOwner():
                         node = node.getParentVariableProvider()
                         node.getLocalsScope().registerClosureVariable(class_var)
+        elif node.isStatementAssignmentVariableGeneric():
+            node.parent.replaceChild(
+                node,
+                makeStatementAssignmentVariable(
+                    source=node.subnode_source,
+                    variable=node.variable,
+                    variable_version=node.variable_version,
+                    source_ref=node.source_ref,
+                ),
+            )
 
 
 def completeVariableClosures(tree):

nuitka/utils/AppDirs.py

@@ -35,7 +35,7 @@ from nuitka.Tracing import general
 from .FileOperations import makePath
 from .Importing import importFromInlineCopy
 
-appdirs = importFromInlineCopy("appdirs", must_exist=False)
+appdirs = importFromInlineCopy("appdirs", must_exist=False, delete_module=True)
 
 if appdirs is None:
     import appdirs  # pylint: disable=I0021,import-error
@@ -73,7 +73,7 @@ def getCacheDir():
                 """\
 Error, failed to create cache directory '%s'. If this is due to a special environment, \
 please consider making a PR for a general solution that adds support for it, or use \
-NUITKA_CACHE_DIR set to a writable directory."""
+'NUITKA_CACHE_DIR' set to a writable directory."""
                 % _cache_dir
             )
 

nuitka/utils/CStrings.py

@@ -24,7 +24,7 @@ values.
 import codecs
 import re
 
-from nuitka.__past__ import unicode
+from nuitka.__past__ import to_byte, unicode
 
 
 def _identifierEncode(c):
@@ -52,7 +52,7 @@ def _encodePythonStringToC(value):
             cv = c
 
         if c in b'\\\t\r\n"?':
-            result += r"\%o" % cv
+            result += r"\%03o" % cv
 
             octal = True
         elif 32 <= cv <= 127:
@@ -81,7 +81,12 @@ def encodePythonUnicodeToC(value):
     for c in value:
         cv = ord(c)
 
-        result += r"\%o" % cv
+        if c == "\\":
+            result += "\\\\"
+        elif 34 < cv < 128:
+            result += c
+        else:
+            result += r"\x%04x" % cv
 
     return 'L"%s"' % result
 
@@ -105,6 +110,37 @@ def encodePythonStringToC(value):
     return result
 
 
+def decodeCStringToPython(value):
+    assert value.startswith('"')
+    value = value[1:-1]
+
+    result = b""
+
+    while value:
+        if value[0] == "\\":
+            value = value[1:]
+            if value[0] == "\\":
+                result += b"\\"
+                continue
+
+            if value[0].isdigit():
+                assert value[1].isdigit(), value
+                assert value[2].isdigit(), value
+
+                octal_number = int(value[2]) + int(value[1]) * 8 + int(value[0]) * 64
+                value = value[3:]
+
+                result += to_byte(octal_number)
+                continue
+
+            assert False, value[0]
+
+        result += value[0].encode("ascii")
+        value = value[1:]
+
+    return result
+
+
 def encodePythonIdentifierToC(value):
     """Encode an identifier from a given Python string."""
 

nuitka/utils/CommandLineOptions.py

@@ -19,7 +19,13 @@
 
 
 import sys
-from optparse import IndentedHelpFormatter, OptionGroup, OptionParser
+from optparse import (
+    AmbiguousOptionError,
+    BadOptionError,
+    IndentedHelpFormatter,
+    OptionGroup,
+    OptionParser,
+)
 
 # For re-export only:
 from optparse import SUPPRESS_HELP  # isort:skip pylint: disable=unused-import
@@ -50,6 +56,41 @@ class OurOptionParser(OptionParser):
 
         return OptionParser._process_long_opt(self, rargs, values)
 
+    def _match_long_opt(self, opt):
+        """_match_long_opt(opt : string) -> string
+
+        Determine which long option string 'opt' matches, ie. which one
+        it is an unambiguous abbreviation for.  Raises BadOptionError if
+        'opt' doesn't unambiguously match any long option string.
+
+        Nuitka: We overload it, in order avoid issues with conflicting
+        options that are really only aliases of the same option.
+        """
+        matched_options = set()
+        possibilities = []
+
+        # Exact matches are never ambiguous. We sometimes append to option names
+        # in order to detail things.
+        for option_name in self._long_opt:
+            if opt == option_name:
+                return opt
+
+        for option_name, option_obj in self._long_opt.items():
+            if option_name.startswith(opt):
+                if option_obj not in matched_options:
+                    matched_options.add(option_obj)
+                    possibilities.append(option_name)
+
+        # No exact match, so there had better be just one possibility.
+        if len(matched_options) > 1:
+            raise AmbiguousOptionError(opt, possibilities)
+
+        if possibilities:
+            assert len(possibilities) == 1, possibilities
+            return possibilities[0]
+        else:
+            raise BadOptionError(opt)
+
     def add_option(self, *args, **kwargs):
         require_compiling = kwargs.pop("require_compiling", True)