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

nuitka/nodes/ExpressionBasesGenerated.py

@@ -744,6 +744,142 @@ ExpressionAttributeLookupBase = ChildHavingExpressionAttributeNameMixin
 ExpressionAttributeLookupSpecialBase = ChildHavingExpressionAttributeNameMixin
 
 
+class ChildrenHavingExpressionNameRaiseWaitConstantNameMixin(ExpressionBase):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionBuiltinHasattr
+
+    def __init__(self, expression, name, source_ref):
+        expression.parent = self
+
+        self.subnode_expression = expression
+
+        name.parent = self
+
+        self.subnode_name = name
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        return (
+            self.subnode_expression,
+            self.subnode_name,
+        )
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (
+            ("expression", self.subnode_expression),
+            ("name", self.subnode_name),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_expression
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_expression = new_node
+
+            return
+
+        value = self.subnode_name
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_name = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "expression": self.subnode_expression.makeClone(),
+            "name": self.subnode_name.makeClone(),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        self.subnode_expression.finalize()
+        del self.subnode_expression
+        self.subnode_name.finalize()
+        del self.subnode_name
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
+
+            if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
+                return (
+                    wrapped_expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        if self.subnode_name.isCompileTimeConstant():
+            try:
+                return self.computeExpressionConstantName(trace_collection)
+            finally:
+                trace_collection.onExceptionRaiseExit(BaseException)
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    @abstractmethod
+    def computeExpression(self, trace_collection):
+        """Must be overloaded for non-final node."""
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        self.subnode_expression.collectVariableAccesses(emit_read, emit_write)
+        self.subnode_name.collectVariableAccesses(emit_read, emit_write)
+
+    @abstractmethod
+    def computeExpressionConstantName(self, trace_collection):
+        """Called when attribute name is constant."""
+
+
+# Assign the names that are easier to import with a stable name.
+ExpressionBuiltinHasattrBase = ChildrenHavingExpressionNameRaiseWaitConstantNameMixin
+
+
 class ChildrenHavingLeftRightFinalNoRaiseMixin(ExpressionBase):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()

nuitka/nodes/HardImportNodesGenerated.py

@@ -47,6 +47,7 @@ from nuitka.specs.HardImportSpecs import (
     importlib_metadata_entry_points_since_310_spec,
     importlib_metadata_metadata_spec,
     importlib_metadata_version_spec,
+    importlib_resources_files_spec,
     importlib_resources_read_binary_spec,
     importlib_resources_read_text_spec,
     os_listdir_spec,
@@ -68,6 +69,7 @@ from nuitka.specs.HardImportSpecs import (
 from .ChildrenHavingMixins import (
     ChildHavingDistMixin,
     ChildHavingDistributionNameMixin,
+    ChildHavingPackageMixin,
     ChildHavingParamsTupleMixin,
     ChildHavingPathMixin,
     ChildHavingPathOptionalMixin,
@@ -1101,6 +1103,98 @@ class ExpressionImportlibMetadataVersionCallBase(
         return True
 
 
+class ExpressionImportlibResourcesFilesRef(
+    ExpressionImportModuleNameHardExistsSpecificBase
+):
+    """Function reference importlib.resources.files"""
+
+    kind = "EXPRESSION_IMPORTLIB_RESOURCES_FILES_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name="importlib.resources",
+            import_name="files",
+            module_guaranteed=True,
+            source_ref=source_ref,
+        )
+
+    def computeExpressionCall(self, call_node, call_args, call_kw, trace_collection):
+        # Anything may happen on call trace before this. On next pass, if
+        # replaced, we might be better but not now.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        from .PackageResourceNodes import ExpressionImportlibResourcesFilesCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionImportlibResourcesFilesCall,
+            builtin_spec=importlib_resources_files_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'importlib.resources.files' recognized.",
+        )
+
+
+hard_import_node_classes[
+    ExpressionImportlibResourcesFilesRef
+] = importlib_resources_files_spec
+
+
+class ExpressionImportlibResourcesFilesCallBase(
+    ChildHavingPackageMixin, ExpressionBase
+):
+    """Base class for ImportlibResourcesFilesCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = ("package",)
+
+    __slots__ = ("attempted",)
+
+    spec = importlib_resources_files_spec
+
+    def __init__(self, package, source_ref):
+
+        ChildHavingPackageMixin.__init__(
+            self,
+            package=package,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        # In module mode, we expect a changing environment, cannot optimize this
+        self.attempted = shallMakeModule()
+
+    def computeExpression(self, trace_collection):
+        if (
+            self.attempted
+            or not importlib_resources_files_spec.isCompileTimeComputable(
+                (self.subnode_package,)
+            )
+        ):
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return self, None, None
+
+        try:
+            return self.replaceWithCompileTimeValue(trace_collection)
+        finally:
+            self.attempted = True
+
+    @abstractmethod
+    def replaceWithCompileTimeValue(self, trace_collection):
+        pass
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return True
+
+
 class ExpressionImportlibResourcesReadBinaryRef(
     ExpressionImportModuleNameHardExistsSpecificBase
 ):

nuitka/nodes/ImportHardNodes.py

@@ -51,7 +51,7 @@ class ExpressionImportHardBase(ExpressionBase):
         assert self.finding != "not-found", self.module_name
         assert _module_name == self.module_name, (self.module_name, _module_name)
 
-    def getModulesUsageAttempt(self):
+    def getModuleUsageAttempt(self):
         return makeModuleUsageAttempt(
             module_name=self.module_name,
             filename=self.module_filename,
@@ -117,7 +117,7 @@ class ExpressionImportModuleNameHardMaybeExists(ExpressionImportModuleNameHardBa
         trace_collection.onExceptionRaiseExit(AttributeError)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModulesUsageAttempt())
+        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
 
         return self, None, None
 
@@ -143,7 +143,7 @@ class ExpressionImportModuleNameHardExists(ExpressionImportModuleNameHardBase):
             trace_collection.onExceptionRaiseExit(ImportError)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModulesUsageAttempt())
+        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
 
         # As good as it gets.
         return self, None, None

nuitka/nodes/ImportNodes.py

@@ -98,6 +98,8 @@ hard_modules = frozenset(
         "pkgutil",
         "functools",
         "sysconfig",
+        "unittest",
+        "unittest.mock",
         # "cStringIO",
         "io",
         "ctypes",
@@ -263,6 +265,9 @@ hard_modules_trust = {
     "pkgutil": {"get_data": trust_node},
     "functools": {"partial": trust_exist},
     "sysconfig": {},
+    # TODO: We should have trust_module too.
+    "unittest": {"mock": trust_exist},
+    "unittest.mock": {},
     "io": {"BytesIO": trust_exist},
     # "cStringIO": {"StringIO": trust_exist},
     "pkg_resources": {
@@ -272,7 +277,11 @@ hard_modules_trust = {
         "resource_string": trust_node,
         "resource_stream": trust_node,
     },
-    "importlib.resources": {"read_binary": trust_node, "read_text": trust_node},
+    "importlib.resources": {
+        "read_binary": trust_node,
+        "read_text": trust_node,
+        "files": trust_node,
+    },
     "ctypes": module_ctypes_trust,
     "site": {},
     "ctypes.wintypes": {},
@@ -369,6 +378,7 @@ class ExpressionImportAllowanceMixin(object):
             self.allowed = True
         else:
             self.allowed, _reason = decideRecursion(
+                using_module_name=None,
                 module_filename=self.module_filename,
                 module_name=self.module_name,
                 module_kind=self.module_kind,
@@ -573,7 +583,7 @@ class ExpressionImportModuleHard(
             trace_collection.onExceptionRaiseExit(BaseException)
 
         # Trace the module usage attempt.
-        trace_collection.onModuleUsageAttempt(self.getModulesUsageAttempt())
+        trace_collection.onModuleUsageAttempt(self.getModuleUsageAttempt())
 
         return self, None, None
 
@@ -1070,7 +1080,7 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
                     break
 
                 (
-                    _module_name_found,
+                    found_module_name,
                     module_filename,
                     module_kind,
                     finding,
@@ -1082,7 +1092,7 @@ class ExpressionBuiltinImport(ChildrenExpressionBuiltinImportMixin, ExpressionBa
 
                 self.used_modules.append(
                     makeModuleUsageAttempt(
-                        module_name=module_name,
+                        module_name=found_module_name,
                         filename=module_filename,
                         module_kind=module_kind,
                         finding=finding,

nuitka/nodes/ModuleNodes.py

@@ -29,6 +29,7 @@ from nuitka.importing.Importing import locateModule
 from nuitka.importing.Recursion import decideRecursion, recurseTo
 from nuitka.ModuleRegistry import getModuleByName, getOwnerFromCodeName
 from nuitka.optimizations.TraceCollections import TraceCollectionModule
+from nuitka.Options import hasPythonFlagIsolated
 from nuitka.PythonVersions import python_version
 from nuitka.SourceCodeReferences import fromFilename
 from nuitka.tree.SourceHandling import parsePyIFile, readSourceCodeFromFilename
@@ -110,6 +111,7 @@ class PythonModuleBase(NodeBase):
             # assert _package_name == self.package_name, (package_filename, _package_name, self.package_name)
 
             decision, _reason = decideRecursion(
+                using_module_name=self.getFullName(),
                 module_filename=package_filename,
                 module_name=package_name,
                 module_kind=package_module_kind,
@@ -123,7 +125,7 @@ class PythonModuleBase(NodeBase):
                     module_name=package_name,
                     module_filename=package_filename,
                     module_kind=package_module_kind,
-                    using_module=self,
+                    using_module_name=self.module_name,
                     source_ref=self.source_ref,
                     reason="Containing package of '%s'." % self.getFullName(),
                 )
@@ -712,7 +714,7 @@ class CompiledPythonPackage(CompiledPythonModule):
 
     @staticmethod
     def canHaveExternalImports():
-        return True
+        return not hasPythonFlagIsolated()
 
 
 def makeUncompiledPythonModule(

nuitka/nodes/PackageMetadataNodes.py

@@ -292,10 +292,12 @@ class ExpressionPkgResourcesDistributionValueRef(
     def computeExpressionAttribute(self, lookup_node, attribute_name, trace_collection):
         # If it raises, or the attribute itself is a compile time constant,
         # then do execute it.
-        if not self.isKnownToHaveAttribute(
-            attribute_name
-        ) or isCompileTimeConstantValue(
-            getattr(self.distribution, attribute_name, None)
+        if (
+            self.isKnownToHaveAttribute(attribute_name)
+            and isCompileTimeConstantValue(
+                getattr(self.distribution, attribute_name, None)
+            )
+            and (attribute_name != "location" or not isStandaloneMode())
         ):
             return trace_collection.getCompileTimeComputationResult(
                 node=lookup_node,
@@ -453,9 +455,7 @@ class ExpressionPkgResourcesEntryPointValueRef(
     def computeExpressionAttribute(self, lookup_node, attribute_name, trace_collection):
         # If it raises, or the attribute itself is a compile time constant,
         # then do execute it.
-        if not self.isKnownToHaveAttribute(
-            attribute_name
-        ) or isCompileTimeConstantValue(
+        if self.isKnownToHaveAttribute(attribute_name) and isCompileTimeConstantValue(
             getattr(self.entry_point, attribute_name, None)
         ):
             return trace_collection.getCompileTimeComputationResult(
@@ -513,6 +513,8 @@ class ExpressionImportlibMetadataDistributionCall(
     ImportlibMetadataDistributionCallMixin,
     ExpressionImportlibMetadataDistributionCallBase,
 ):
+    """Represents call to importlib.metadata.distribution(distribution_name)"""
+
     kind = "EXPRESSION_IMPORTLIB_METADATA_DISTRIBUTION_CALL"
 
     python_version_spec = ">= 0x380"
@@ -524,6 +526,8 @@ class ExpressionImportlibMetadataBackportDistributionCall(
     ImportlibMetadataDistributionCallMixin,
     ExpressionImportlibMetadataDistributionCallBase,
 ):
+    """Represents call to importlib_metadata.distribution(distribution_name)"""
+
     kind = "EXPRESSION_IMPORTLIB_METADATA_BACKPORT_DISTRIBUTION_CALL"
     importlib_metadata_name = "importlib_metadata"
 
@@ -586,9 +590,7 @@ class ExpressionImportlibMetadataEntryPointValueMixin(object):
     def computeExpressionAttribute(self, lookup_node, attribute_name, trace_collection):
         # If it raises, or the attribute itself is a compile time constant,
         # then do execute it.
-        if not self.isKnownToHaveAttribute(
-            attribute_name
-        ) or isCompileTimeConstantValue(
+        if self.isKnownToHaveAttribute(attribute_name) and isCompileTimeConstantValue(
             getattr(self.entry_point, attribute_name, None)
         ):
             return trace_collection.getCompileTimeComputationResult(

nuitka/nodes/PackageResourceNodes.py

@@ -17,12 +17,17 @@
 #
 """ Nodes the represent ways to access package data for pkglib, pkg_resources, etc. """
 
+from nuitka.importing.Importing import locateModule, makeModuleUsageAttempt
+from nuitka.importing.ImportResolving import resolveModuleName
+
 from .ConstantRefNodes import makeConstantRefNode
+from .ExpressionBases import ExpressionBase
 from .ExpressionShapeMixins import (
     ExpressionBytesShapeExactMixin,
     ExpressionStrShapeExactMixin,
 )
 from .HardImportNodesGenerated import (
+    ExpressionImportlibResourcesFilesCallBase,
     ExpressionImportlibResourcesReadBinaryCallBase,
     ExpressionImportlibResourcesReadTextCallBase,
     ExpressionPkgResourcesResourceStreamCallBase,
@@ -136,3 +141,113 @@ class ExpressionImportlibResourcesReadTextCall(
         trace_collection.onExceptionRaiseExit(BaseException)
 
         return self, None, None
+
+
+class ExpressionImportlibResourcesFilesCallMixin:
+    __slots__ = ()
+
+    # TODO: Looks as if this could be a convenience function of more general use.
+    def makeModuleUsageAttempt(self, package_name):
+        _package_name, module_filename, module_kind, finding = locateModule(
+            module_name=package_name,
+            parent_package=None,
+            level=0,
+        )
+
+        return makeModuleUsageAttempt(
+            module_name=package_name,
+            filename=module_filename,
+            module_kind=module_kind,
+            finding=finding,
+            level=0,
+            source_ref=self.source_ref,
+        )
+
+    # TODO: In standalone mode we could know a lot better.
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return True
+
+
+class ExpressionImportlibResourcesFilesCallFixed(
+    ExpressionImportlibResourcesFilesCallMixin, ExpressionBase
+):
+    kind = "EXPRESSION_IMPORTLIB_RESOURCES_FILES_CALL_FIXED"
+
+    python_version_spec = ">= 0x370"
+
+    __slots__ = (
+        "package_name",
+        "module_usage_attempt",
+    )
+
+    def __init__(self, package_name, source_ref):
+        ExpressionBase.__init__(self, source_ref)
+
+        self.package_name = resolveModuleName(package_name)
+
+        self.module_usage_attempt = self.makeModuleUsageAttempt(
+            package_name=package_name
+        )
+
+    def finalize(self):
+        del self.module_usage_attempt
+
+    def getPackageNameUsed(self):
+        return makeConstantRefNode(
+            constant=self.package_name.asString(), source_ref=self.source_ref
+        )
+
+    def computeExpressionRaw(self, trace_collection):
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        trace_collection.onModuleUsageAttempt(self.module_usage_attempt)
+
+        return self, None, None
+
+
+class ExpressionImportlibResourcesFilesCall(
+    ExpressionImportlibResourcesFilesCallMixin,
+    ExpressionImportlibResourcesFilesCallBase,
+):
+    kind = "EXPRESSION_IMPORTLIB_RESOURCES_FILES_CALL"
+
+    python_version_spec = ">= 0x370"
+
+    named_children = ("package",)
+
+    __slots__ = ("module_usage_attempt",)
+
+    def __init__(self, package, source_ref):
+        ExpressionImportlibResourcesFilesCallBase.__init__(
+            self, package=package, source_ref=source_ref
+        )
+
+        self.module_usage_attempt = None
+
+    def getPackageNameUsed(self):
+        return self.subnode_package
+
+    def replaceWithCompileTimeValue(self, trace_collection):
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        package_name = self.subnode_package.getCompileTimeConstant()
+
+        if type(package_name) is str:
+            package_name = resolveModuleName(package_name)
+            trace_collection.onModuleUsageAttempt(
+                self.makeModuleUsageAttempt(package_name)
+            )
+
+            result = ExpressionImportlibResourcesFilesCallFixed(
+                package_name=package_name, source_ref=self.source_ref
+            )
+
+            return (
+                result,
+                "new_expression",
+                "Detected 'importlib.resources.files' with constant package name '%s'."
+                % package_name,
+            )
+
+        return self, None, None

nuitka/nodes/TypeNodes.py

@@ -22,6 +22,7 @@ them, their relationship or check for them in re-formulations.
 
 """
 
+from nuitka.__past__ import GenericAlias
 from nuitka.Builtins import builtin_names
 from nuitka.Options import isExperimental
 
@@ -93,7 +94,10 @@ class ExpressionBuiltinType1(ExpressionBuiltinSingleArgBase):
             # The above code is supposed to catch these in a better way.
             value = value.getCompileTimeConstant()
 
-            type_name = value.__class__.__name__
+            if type(value) is GenericAlias:
+                type_name = "GenericAlias"
+            else:
+                type_name = value.__class__.__name__
 
             if type_name in builtin_names:
                 new_node = makeExpressionBuiltinRef(