Nuitka-winsvc 1.6.6__cp310-cp310-win_amd64.whl → 1.7.5__cp310-cp310-win_amd64.whl

nuitka/code_generation/CodeGeneration.py

@@ -284,6 +284,7 @@ from .PackageResourceCodes import (
     generateImportlibMetadataEntryPointValueCode,
     generateImportlibMetadataSelectableGroupsValueCode,
     generateImportlibMetadataVersionCallCode,
+    generateImportlibResourcesFilesCallCode,
     generateImportlibResourcesReadBinaryCallCode,
     generateImportlibResourcesReadTextCallCode,
     generateOsListdirCallCode,
@@ -887,6 +888,7 @@ addExpressionDispatchDict(
         "EXPRESSION_PKG_RESOURCES_ENTRY_POINT_VALUE_REF": generatePkgResourcesEntryPointValueCode,
         "EXPRESSION_IMPORTLIB_RESOURCES_READ_BINARY_REF": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORTLIB_RESOURCES_READ_TEXT_REF": generateImportModuleNameHardCode,
+        "EXPRESSION_IMPORTLIB_RESOURCES_FILES_REF": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORTLIB_METADATA_VERSION_REF": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORTLIB_METADATA_BACKPORT_VERSION_REF": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORTLIB_METADATA_DISTRIBUTION_REF": generateImportModuleNameHardCode,
@@ -922,6 +924,8 @@ addExpressionDispatchDict(
         "EXPRESSION_PKG_RESOURCES_RESOURCE_STREAM_CALL": generatePkgResourcesResourceStreamCallCode,
         "EXPRESSION_IMPORTLIB_RESOURCES_READ_BINARY_CALL": generateImportlibResourcesReadBinaryCallCode,
         "EXPRESSION_IMPORTLIB_RESOURCES_READ_TEXT_CALL": generateImportlibResourcesReadTextCallCode,
+        "EXPRESSION_IMPORTLIB_RESOURCES_FILES_CALL": generateImportlibResourcesFilesCallCode,
+        "EXPRESSION_IMPORTLIB_RESOURCES_FILES_CALL_FIXED": generateImportlibResourcesFilesCallCode,
         "EXPRESSION_IMPORTLIB_METADATA_VERSION_CALL": generateImportlibMetadataVersionCallCode,
         "EXPRESSION_IMPORTLIB_METADATA_BACKPORT_VERSION_CALL": generateImportlibMetadataBackportVersionCallCode,
         "EXPRESSION_IMPORTLIB_METADATA_BACKPORT_DISTRIBUTION_CALL": generateImportlibMetadataDistributionCallCode,

nuitka/code_generation/FunctionCodes.py

@@ -527,10 +527,17 @@ def setupFunctionLocalVariables(
             context=context, variable=variable
         )
 
+        # Delay cell variable initialization for outlines to their own code.
+        if (
+            variable_c_type is CTypeCellObject
+            and variable.owner.isExpressionOutlineFunctionBase()
+        ):
+            init_value = "NULL"
+        else:
+            init_value = variable_c_type.getInitValue(None)
+
         variable_declaration = context.variable_storage.addVariableDeclarationTop(
-            variable_c_type.c_type,
-            variable_code_name,
-            variable_c_type.getInitValue(None),
+            variable_c_type.c_type, variable_code_name, init_value
         )
 
         context.setVariableType(variable, variable_declaration)
@@ -778,6 +785,14 @@ def generateFunctionOutlineCode(to_name, expression, emit, context):
     if expression.isExpressionOutlineFunctionBase():
         context = PythonFunctionOutlineContext(parent=context, outline=expression)
 
+        for variable in expression.getUserLocalVariables():
+            variable_declaration = getLocalVariableDeclaration(
+                context=context, variable=variable, variable_trace=None
+            )
+
+            if variable_declaration.getCType() is CTypeCellObject:
+                emit("%s = Nuitka_Cell_Empty();" % variable_declaration)
+
     # Need to set return target, to assign to_name from.
 
     return_target = context.allocateLabel("outline_result")

nuitka/code_generation/GlobalConstants.py

@@ -34,7 +34,7 @@ def getConstantDefaultPopulation():
     be constructed through code.
     """
 
-    # Lots of cases, pylint: disable=too-many-branches
+    # Lots of cases, pylint: disable=too-many-branches,too-many-statements
 
     # Note: Can't work with set here, because we need to put in some values that
     # cannot be hashed.
@@ -196,8 +196,15 @@ def getConstantDefaultPopulation():
         result.append("register")
 
     if python_version >= 0x370:
+        # New class method
         result.append("__class_getitem__")
 
+    if python_version >= 0x370:
+        # Reconfiguring stdout
+        result.append("reconfigure")
+        result.append("encoding")
+        result.append("line_buffering")
+
     if python_version >= 0x3A0:
         result.append("__match_args__")
 

nuitka/code_generation/PackageResourceCodes.py

@@ -27,6 +27,7 @@ from .CallCodes import (
 )
 from .CodeHelpers import (
     decideConversionCheckNeeded,
+    generateChildExpressionCode,
     generateChildExpressionsCode,
     withObjectCodeTemporaryAssignment,
 )
@@ -91,6 +92,13 @@ def generatePkgResourcesDistributionValueCode(to_name, expression, emit, context
             for kw_name in kw_names
         ]
 
+        # Standalone mode, has a different location.
+        if "location" not in kw_names:
+            kw_names += ("location",)
+        dict_value_names.append(
+            'LOOKUP_BUILTIN_STR("__nuitka_binary_dir")',
+        )
+
         getCallCodeKwSplit(
             to_name=result_name,
             called_name=distribution_class_name,
@@ -725,6 +733,38 @@ def generateImportlibResourcesReadTextCallCode(to_name, expression, emit, contex
         )
 
 
+def generateImportlibResourcesFilesCallCode(to_name, expression, emit, context):
+    package_name = generateChildExpressionCode(
+        expression=expression.getPackageNameUsed(),
+        child_name="package_name",
+        emit=emit,
+        context=context,
+    )
+
+    with withObjectCodeTemporaryAssignment(
+        to_name, "files_value", expression, emit, context
+    ) as result_name:
+        files_function = context.allocateTempName("files_function", unique=True)
+
+        getImportModuleNameHardCode(
+            to_name=files_function,
+            module_name="importlib.resources",
+            import_name="files",
+            needs_check=False,
+            emit=emit,
+            context=context,
+        )
+
+        getCallCodePosArgsQuick(
+            to_name=result_name,
+            called_name=files_function,
+            expression=expression,
+            arg_names=(package_name,),
+            emit=emit,
+            context=context,
+        )
+
+
 def generatePkgResourcesResourceStreamCallCode(to_name, expression, emit, context):
     package_name, resource_name = generateChildExpressionsCode(
         expression=expression, emit=emit, context=context

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -332,15 +332,9 @@ PyObject *modulecode_%(module_identifier)s(PyObject *module, struct Nuitka_MetaP
 #endif
 
         /* The constants only used by this module are created now. */
-#ifdef _NUITKA_TRACE
-        PRINT_STRING("%(module_name)s: Calling createModuleConstants().\n");
-#endif
+        NUITKA_PRINT_TRACE("%(module_name)s: Calling createModuleConstants().\n");
         createModuleConstants();
 
-        /* The code objects used by this module are created now. */
-#ifdef _NUITKA_TRACE
-        PRINT_STRING("%(module_name)s: Calling createModuleCodeObjects().\n");
-#endif
         createModuleCodeObjects();
 
         init_done = true;

nuitka/freezer/DllDependenciesMacOS.py

@@ -18,6 +18,7 @@
 """DLL dependency scan methods for macOS. """
 
 import os
+import re
 import sys
 
 from nuitka.containers.OrderedDicts import OrderedDict
@@ -146,7 +147,7 @@ def _resolveBinaryPathDLLsMacOS(
     original_dir, binary_filename, paths, package_specific_dirs, package_name
 ):
     # Quite a few variations to consider
-    # pylint: disable=too-many-branches,too-many-locals
+    # pylint: disable=too-many-branches,too-many-locals,too-many-statements
 
     had_self = False
 
@@ -204,6 +205,22 @@ def _resolveBinaryPathDLLsMacOS(
             if candidate is not None and os.path.exists(candidate):
                 resolved_path = candidate
 
+        # Sometimes self-dependencies are on a numbered version, but deployed is
+        # one version without it. The macOS just ignores that, and so we do.
+        if not os.path.exists(resolved_path):
+            match = re.match(r"^(.*)\.\d+\.dylib$", resolved_path)
+
+            if match:
+                candidate = match.group(1) + ".dylib"
+
+                if os.path.exists(candidate):
+                    resolved_path = candidate
+                else:
+                    candidate = os.path.join(original_dir, os.path.basename(candidate))
+
+                    if os.path.exists(candidate):
+                        resolved_path = candidate
+
         if not os.path.exists(resolved_path):
             acceptable, plugin_name = Plugins.isAcceptableMissingDLL(
                 package_name=package_name,

nuitka/freezer/IncludedDataFiles.py

@@ -49,7 +49,6 @@ from nuitka.utils.FileOperations import (
     isRelativePath,
     makePath,
     openTextFile,
-    putTextFileContents,
     relpath,
     resolveShellPatternToFilenames,
 )
@@ -251,10 +250,10 @@ def makeIncludedDataDirectory(
 def makeIncludedGeneratedDataFile(data, dest_path, reason, tracer, tags):
     assert isRelativePath(dest_path), dest_path
 
-    # Handle lists of bytes here already by converting to single bytes value.
-    if type(data) is list:
-        if str is not bytes and all(type(element) is bytes for element in data):
-            data = b"\n".join(data)
+    if type(data) is str and str is not bytes:
+        data = data.encode("utf8")
+
+    assert type(data) is bytes, type(data)
 
     return IncludedDataFile(
         kind="data_blob",
@@ -520,11 +519,8 @@ def _handleDataFile(included_datafile):
         dest_path = os.path.join(dist_dir, included_datafile.dest_path)
         makePath(os.path.dirname(dest_path))
 
-        if type(included_datafile.data) is bytes:
-            with openTextFile(filename=dest_path, mode="wb") as output_file:
-                output_file.write(included_datafile.data)
-        else:
-            putTextFileContents(filename=dest_path, contents=included_datafile.data)
+        with openTextFile(filename=dest_path, mode="wb") as output_file:
+            output_file.write(included_datafile.data)
     elif included_datafile.kind == "data_file":
         dest_path = os.path.join(dist_dir, included_datafile.dest_path)
 

nuitka/importing/ImportResolving.py

@@ -23,6 +23,9 @@ from nuitka.__past__ import unicode
 from nuitka.PythonVersions import python_version
 from nuitka.utils.ModuleNames import ModuleName
 
+# spell-checker: ignore Tkdnd gdbm cookielib htmlentitydefs CGIHTTPServer Tkconstants
+# spell-checker: ignore tkinter_tkfiledialog tkinter_tksimpledialog xmlrpclib
+
 _six_moves = {
     "six.moves.builtins": "__builtin__" if python_version < 0x300 else "builtins",
     "six.moves.configparser": "ConfigParser"
@@ -117,6 +120,9 @@ _six_moves = {
     if python_version < 0x300
     else "xmlrpc.server",
     "six.moves.winreg": "_winreg" if python_version < 0x300 else "winreg",
+    "six.moves.urllib.request": "urllib2"
+    if python_version < 0x300
+    else "urllib.request",
 }
 
 

nuitka/importing/Recursion.py

@@ -34,8 +34,6 @@ from nuitka.utils.FileOperations import listDir
 from nuitka.utils.Importing import getSharedLibrarySuffixes
 from nuitka.utils.ModuleNames import ModuleName
 
-from .Importing import locateModule
-
 
 def _recurseTo(module_name, module_filename, module_kind):
     from nuitka.tree import Building
@@ -61,7 +59,7 @@ def recurseTo(
     module_name,
     module_filename,
     module_kind,
-    using_module,
+    using_module_name,
     source_ref,
     reason,
 ):
@@ -77,7 +75,7 @@ def recurseTo(
             module_filename=module_filename,
             module_name=module_name,
             module_kind=module_kind,
-            using_module=using_module,
+            using_module_name=using_module_name,
             source_ref=source_ref,
         )
 
@@ -96,18 +94,26 @@ def recurseTo(
 _recursion_decision_cache = {}
 
 
-def decideRecursion(module_filename, module_name, module_kind, extra_recursion=False):
-    key = module_filename, module_name, module_kind, extra_recursion
+def decideRecursion(
+    using_module_name, module_filename, module_name, module_kind, extra_recursion=False
+):
+    key = using_module_name, module_filename, module_name, module_kind, extra_recursion
 
     if key not in _recursion_decision_cache:
         _recursion_decision_cache[key] = _decideRecursion(
-            module_filename, module_name, module_kind, extra_recursion
+            using_module_name,
+            module_filename,
+            module_name,
+            module_kind,
+            extra_recursion,
         )
 
     return _recursion_decision_cache[key]
 
 
-def _decideRecursion(module_filename, module_name, module_kind, extra_recursion):
+def _decideRecursion(
+    using_module_name, module_filename, module_name, module_kind, extra_recursion
+):
     # Many branches, which make decisions immediately, by returning
     # pylint: disable=too-many-branches,too-many-return-statements
     if module_name == "__main__":
@@ -123,6 +129,7 @@ def _decideRecursion(module_filename, module_name, module_kind, extra_recursion)
             return False, "Main program is already included in package mode."
 
     plugin_decision = Plugins.onModuleEncounter(
+        using_module_name=using_module_name,
         module_filename=module_filename,
         module_name=module_name,
         module_kind=module_kind,
@@ -292,6 +299,7 @@ the compiled result, and therefore asking to include them makes no sense.
 
     if module_kind is not None:
         decision, reason = decideRecursion(
+            using_module_name=None,
             module_filename=plugin_filename,
             module_name=module_name,
             module_kind=module_kind,
@@ -304,7 +312,7 @@ the compiled result, and therefore asking to include them makes no sense.
                 module_filename=plugin_filename,
                 module_name=module_name,
                 module_kind=module_kind,
-                using_module=None,
+                using_module_name=None,
                 source_ref=None,
                 reason=reason,
             )
@@ -376,53 +384,6 @@ def checkPluginFilenamePattern(pattern):
         )
 
 
-def _addParentPackageUsages(using_module, module_name, signal_change, source_ref):
-    for parent_package_name in module_name.getParentPackageNames():
-        (
-            _parent_package_name,
-            parent_package_filename,
-            package_module_kind,
-            finding,
-        ) = locateModule(module_name=parent_package_name, parent_package=None, level=0)
-
-        if parent_package_filename is None:
-            recursion_logger.sysexit(
-                "Error, failed to locate parent package file for '%s' parent of '%s' (used by '%s') module (%s)"
-                % (
-                    parent_package_name,
-                    module_name,
-                    using_module.getFullName(),
-                    finding,
-                )
-            )
-
-        assert _parent_package_name == parent_package_name
-
-        _decision, reason = decideRecursion(
-            module_filename=parent_package_filename,
-            module_name=parent_package_name,
-            module_kind=package_module_kind,
-        )
-
-        used_package_module = recurseTo(
-            signal_change=signal_change,
-            module_name=parent_package_name,
-            module_filename=parent_package_filename,
-            module_kind=package_module_kind,
-            using_module=using_module,
-            source_ref=source_ref,
-            reason=reason,
-        )
-
-        addUsedModule(
-            module=used_package_module,
-            using_module=using_module,
-            usage_tag="package",
-            reason=reason,
-            source_ref=source_ref,
-        )
-
-
 def considerUsedModules(module, signal_change):
     for used_module in module.getUsedModules():
         if used_module.finding == "not-found":
@@ -439,26 +400,20 @@ def considerUsedModules(module, signal_change):
 
         try:
             decision, reason = decideRecursion(
+                using_module_name=module.getFullName(),
                 module_filename=used_module.filename,
                 module_name=used_module.module_name,
                 module_kind=used_module.module_kind,
             )
 
             if decision:
-                _addParentPackageUsages(
-                    using_module=module,
-                    module_name=used_module.module_name,
-                    signal_change=signal_change,
-                    source_ref=used_module.source_ref,
-                )
-
                 new_module = recurseTo(
                     signal_change=signal_change,
                     module_name=used_module.module_name,
                     module_filename=used_module.filename,
                     module_kind=used_module.module_kind,
                     source_ref=used_module.source_ref,
-                    using_module=module,
+                    using_module_name=module.module_name,
                     reason=reason,
                 )
 
@@ -471,9 +426,10 @@ def considerUsedModules(module, signal_change):
                 )
         except NuitkaForbiddenImportEncounter as e:
             recursion_logger.sysexit(
-                "Error, forbidden import of '%s' in module '%s' at '%s' encountered."
+                "Error, forbidden import of '%s' (intending to avoid '%s') in module '%s' at '%s' encountered."
                 % (
-                    e,
+                    e.args[0],
+                    e.args[1],
                     module.getFullName(),
                     used_module.source_ref.getAsString(),
                 )
@@ -483,6 +439,6 @@ def considerUsedModules(module, signal_change):
         Plugins.considerImplicitImports(module=module, signal_change=signal_change)
     except NuitkaForbiddenImportEncounter as e:
         recursion_logger.sysexit(
-            "Error, forbidden import of '%s' done implicitly by module '%s'."
-            % (e, module.getFullName())
+            "Error, forbidden import of '%s' (intending to avoid '%s') done implicitly by module '%s'."
+            % (e.args[0], e.args[1], module.getFullName())
         )

nuitka/nodes/AttributeNodes.py

@@ -34,16 +34,23 @@ work on, and let them decide and do the heavy lifting of optimization
 and annotation is happening in the nodes that implement these compute slots.
 """
 
+from nuitka.__past__ import unicode
+
 from .AttributeLookupNodes import ExpressionAttributeLookup
 from .ChildrenHavingMixins import (
     ChildHavingExpressionMixin,
     ChildrenExpressionBuiltinGetattrMixin,
-    ChildrenExpressionBuiltinHasattrMixin,
     ChildrenExpressionBuiltinSetattrMixin,
 )
 from .ExpressionBases import ExpressionBase
+from .ExpressionBasesGenerated import ExpressionBuiltinHasattrBase
+from .ExpressionShapeMixins import (
+    ExpressionBoolShapeExactMixin,
+    ExpressionNoneShapeExactMixin,
+)
 from .NodeMakingHelpers import (
     makeCompileTimeConstantReplacementNode,
+    makeRaiseExceptionReplacementExpression,
     wrapExpressionWithNodeSideEffects,
 )
 from .StatementBasesGenerated import (
@@ -202,7 +209,9 @@ attribute '%s' to mere attribute lookup"""
         return self, None, None
 
 
-class ExpressionBuiltinSetattr(ChildrenExpressionBuiltinSetattrMixin, ExpressionBase):
+class ExpressionBuiltinSetattr(
+    ExpressionNoneShapeExactMixin, ChildrenExpressionBuiltinSetattrMixin, ExpressionBase
+):
     """Built-in "setattr".
 
     Typical code like this: setattr(source, attribute, value)
@@ -210,13 +219,13 @@ class ExpressionBuiltinSetattr(ChildrenExpressionBuiltinSetattrMixin, Expression
 
     kind = "EXPRESSION_BUILTIN_SETATTR"
 
-    named_children = ("expression", "attribute", "value")
+    named_children = ("expression", "name", "value")
 
     def __init__(self, expression, name, value, source_ref):
         ChildrenExpressionBuiltinSetattrMixin.__init__(
             self,
             expression=expression,
-            attribute=name,
+            name=name,
             value=value,
         )
 
@@ -240,17 +249,12 @@ class ExpressionBuiltinSetattr(ChildrenExpressionBuiltinSetattrMixin, Expression
         return self, None, None
 
 
-class ExpressionBuiltinHasattr(ChildrenExpressionBuiltinHasattrMixin, ExpressionBase):
+class ExpressionBuiltinHasattr(ExpressionBuiltinHasattrBase):
     kind = "EXPRESSION_BUILTIN_HASATTR"
 
-    named_children = ("expression", "attribute")
+    named_children = ("expression", "name")
 
-    def __init__(self, expression, name, source_ref):
-        ChildrenExpressionBuiltinHasattrMixin.__init__(
-            self, expression=expression, attribute=name
-        )
-
-        ExpressionBase.__init__(self, source_ref)
+    auto_compute_handling = "wait_constant:name,raise"
 
     def computeExpression(self, trace_collection):
         # We do at least for compile time constants optimization here, but more
@@ -258,7 +262,7 @@ class ExpressionBuiltinHasattr(ChildrenExpressionBuiltinHasattrMixin, Expression
         source = self.subnode_expression
 
         if source.isCompileTimeConstant():
-            attribute = self.subnode_attribute
+            attribute = self.subnode_name
 
             attribute_name = attribute.getStringValue()
 
@@ -292,8 +296,42 @@ class ExpressionBuiltinHasattr(ChildrenExpressionBuiltinHasattrMixin, Expression
 
         return self, None, None
 
+    def computeExpressionConstantName(self, trace_collection):
+        attribute_name = self.subnode_name.getCompileTimeConstant()
+
+        if type(attribute_name) not in (str, unicode):
+            result = makeRaiseExceptionReplacementExpression(
+                expression=self,
+                exception_type="TypeError",
+                exception_value="attribute name must be string",
+            )
+
+            return (
+                result,
+                "new_raise",
+                "Call to hasattr with non-str type %s attribute name"
+                % type(attribute_name),
+            )
+
+        if str is not unicode:
+            attribute_name = attribute_name.encode()
+
+        result = ExpressionAttributeCheck(
+            expression=self.subnode_expression,
+            attribute_name=attribute_name,
+            source_ref=self.source_ref,
+        )
 
-class ExpressionAttributeCheck(ChildHavingExpressionMixin, ExpressionBase):
+        return trace_collection.computedExpressionResult(
+            expression=result,
+            change_tags="new_expression",
+            change_desc="Built-in 'hasattr' with constant attribute name.",
+        )
+
+
+class ExpressionAttributeCheck(
+    ExpressionBoolShapeExactMixin, ChildHavingExpressionMixin, ExpressionBase
+):
     kind = "EXPRESSION_ATTRIBUTE_CHECK"
 
     named_children = ("expression",)
@@ -330,15 +368,30 @@ class ExpressionAttributeCheck(ChildHavingExpressionMixin, ExpressionBase):
                 "Attribute check has been pre-computed to '%s'." % has_attribute,
             )
 
-        # Attribute check is implemented by getting an attribute.
-        if source.mayRaiseExceptionAttributeLookup(BaseException, self.attribute_name):
+        # Attribute check does not raise is implemented by getting an attribute.
+        if self.mayRaiseExceptionOperation():
             trace_collection.onExceptionRaiseExit(BaseException)
 
         return self, None, None
 
-    @staticmethod
-    def mayRaiseException(exception_type):
-        return False
+    def mayRaiseException(self, exception_type):
+        return (
+            self.subnode_expression.mayRaiseException(exception_type)
+            or self.mayRaiseExceptionOperation()
+        )
+
+    if str is bytes:
+
+        @staticmethod
+        def mayRaiseExceptionOperation():
+            return False
+
+    else:
+
+        def mayRaiseExceptionOperation(self):
+            return self.subnode_expression.mayRaiseExceptionAttributeLookup(
+                BaseException, self.attribute_name
+            )
 
     def getAttributeName(self):
         return self.attribute_name