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

nuitka/nodes/OsSysNodes.py

@@ -5,18 +5,22 @@
 
 import os
 
-from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
 from .ConstantRefNodes import makeConstantRefNode
-from .ExceptionNodes import ExpressionRaiseException
+from .ExceptionNodes import (
+    ExpressionRaiseException,
+    makeBuiltinMakeExceptionNode,
+)
 from .ExpressionBases import ExpressionNoSideEffectsMixin
 from .HardImportNodesGenerated import (
     ExpressionOsListdirCallBase,
+    ExpressionOsLstatCallBase,
     ExpressionOsPathAbspathCallBase,
     ExpressionOsPathBasenameCallBase,
     ExpressionOsPathExistsCallBase,
     ExpressionOsPathIsabsCallBase,
     ExpressionOsPathIsdirCallBase,
     ExpressionOsPathIsfileCallBase,
+    ExpressionOsStatCallBase,
     ExpressionOsUnameCallBase,
 )
 
@@ -155,15 +159,42 @@ class ExpressionOsListdirCall(ExpressionOsListdirCallBase):
         return self, None, None
 
 
+class ExpressionOsStatCall(ExpressionOsStatCallBase):
+    kind = "EXPRESSION_OS_STAT_CALL"
+
+    def replaceWithCompileTimeValue(self, trace_collection):
+        # Nothing we can do really
+
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+
+class ExpressionOsLstatCall(ExpressionOsLstatCallBase):
+    kind = "EXPRESSION_OS_LSTAT_CALL"
+
+    def replaceWithCompileTimeValue(self, trace_collection):
+        # Nothing we can do really
+
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+
 def makeExpressionSysExitCall(exit_code, source_ref):
+
     if exit_code is None:
-        exit_code = makeConstantRefNode(constant=None, source_ref=source_ref)
+        args = ()
+    else:
+        args = (exit_code,)
 
     return ExpressionRaiseException(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name="SystemExit", source_ref=source_ref
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name="SystemExit",
+            args=args,
+            for_raise=True,
+            source_ref=source_ref,
         ),
-        exception_value=exit_code,
         source_ref=source_ref,
     )
 

nuitka/nodes/OutlineNodes.py

@@ -139,9 +139,9 @@ class ExpressionOutlineBody(ChildHavingBodyOptionalMixin, ExpressionBase):
         if first_statement.isStatementRaiseException():
             # Exception exit was already annotated, need not repeat it.
 
+            assert first_statement.subnode_exception_value is None, first_statement
             result = ExpressionRaiseException(
                 exception_type=first_statement.subnode_exception_type,
-                exception_value=first_statement.subnode_exception_value,
                 source_ref=first_statement.getSourceReference(),
             )
 
@@ -264,9 +264,9 @@ class ExpressionOutlineFunctionBase(ExpressionFunctionBodyBase):
         if first_statement.isStatementRaiseException():
             # Exception exit was already annotated, need not repeat it.
 
+            assert first_statement.subnode_exception_value is None, first_statement
             result = ExpressionRaiseException(
                 exception_type=first_statement.subnode_exception_type,
-                exception_value=first_statement.subnode_exception_value,
                 source_ref=first_statement.getSourceReference(),
             )
 

nuitka/nodes/StatementBasesGenerated.py

@@ -690,7 +690,6 @@ class StatementChildrenHavingExceptionTypeExceptionValueOptionalExceptionTraceOp
 
     # This is generated for use in
     #   StatementRaiseException
-    #   StatementRaiseExceptionImplicit
 
     def __init__(
         self,
@@ -878,7 +877,6 @@ class StatementChildrenHavingExceptionTypeExceptionValueOptionalExceptionTraceOp
 
 # Assign the names that are easier to import with a stable name.
 StatementRaiseExceptionBase = StatementChildrenHavingExceptionTypeExceptionValueOptionalExceptionTraceOptionalExceptionCauseOptionalOperationPostInitMixin
-StatementRaiseExceptionImplicitBase = StatementChildrenHavingExceptionTypeExceptionValueOptionalExceptionTraceOptionalExceptionCauseOptionalOperationPostInitMixin
 
 
 class StatementChildHavingExpressionOperationAttributeNameMixin(StatementBase):

nuitka/nodes/StatementNodes.py

@@ -27,6 +27,10 @@ class StatementsSequenceMixin(object):
     def isStatementsSequence():
         return True
 
+    def computeStatement(self, trace_collection):
+        # Don't want to be called like this.
+        assert False, self
+
     def trimStatements(self, statement):
         assert statement.parent is self
 
@@ -119,9 +123,9 @@ class StatementsSequence(StatementsSequenceMixin, StatementsSequenceBase):
 
     named_children = ("statements|tuple+setter",)
 
-    def computeStatement(self, trace_collection):
-        # Don't want to be called like this.
-        assert False, self
+    @staticmethod
+    def isStatementsSequenceButNotFrame():
+        return True
 
     def computeStatementsSequence(self, trace_collection):
         new_statements = []
@@ -137,10 +141,7 @@ class StatementsSequence(StatementsSequenceMixin, StatementsSequenceBase):
                 new_statement = trace_collection.onStatement(statement=statement)
 
             if new_statement is not None:
-                if (
-                    new_statement.isStatementsSequence()
-                    and not new_statement.isStatementsFrame()
-                ):
+                if new_statement.isStatementsSequenceButNotFrame():
                     new_statements.extend(new_statement.subnode_statements)
                 else:
                     new_statements.append(new_statement)

nuitka/nodes/SubscriptNodes.py

@@ -195,7 +195,7 @@ class ExpressionSubscriptLookupForUnpack(ExpressionSubscriptLookup):
         # Rewrite exceptions to correct message.
         if (
             result_node.isExpressionRaiseException()
-            and result_node.subnode_exception_type.isExpressionBuiltinExceptionRef()
+            and result_node.subnode_exception_type.isExpressionBuiltinMakeException()
             and result_node.subnode_exception_type.getExceptionName() == "IndexError"
         ):
             if python_version >= 0x360:

nuitka/nodes/TypeNodes.py

@@ -24,10 +24,14 @@ from .ChildrenHavingMixins import (
     ChildrenExpressionBuiltinSuper1Mixin,
     ChildrenExpressionBuiltinSuper2Mixin,
     ChildrenExpressionTypeAliasMixin,
+    ChildrenExpressionTypeMakeGenericMixin,
     ChildrenHavingInstanceClassesMixin,
 )
 from .ExpressionBases import ExpressionBase, ExpressionBuiltinSingleArgBase
-from .ExpressionBasesGenerated import ExpressionSubtypeCheckBase
+from .ExpressionBasesGenerated import (
+    ExpressionSubtypeCheckBase,
+    ExpressionTypeVariableBase,
+)
 from .ExpressionShapeMixins import ExpressionBoolShapeExactMixin
 from .NodeBases import SideEffectsFromChildrenMixin
 from .NodeMakingHelpers import (
@@ -347,6 +351,29 @@ class ExpressionTypeAlias(ChildrenExpressionTypeAliasMixin, ExpressionBase):
         return False
 
 
+class ExpressionTypeVariable(ExpressionTypeVariableBase, ExpressionBase):
+    kind = "EXPRESSION_TYPE_VARIABLE"
+
+    auto_compute_handling = "final,no_raise"
+    node_attributes = ("name",)
+
+
+class ExpressionTypeMakeGeneric(ChildrenExpressionTypeMakeGenericMixin, ExpressionBase):
+    kind = "EXPRESSION_TYPE_MAKE_GENERIC"
+
+    named_children = ("type_params",)
+
+    def __init__(self, type_params, source_ref):
+        ChildrenExpressionTypeMakeGenericMixin.__init__(self, type_params=type_params)
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def computeExpression(self, trace_collection):
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/nodes/shapes/BuiltinTypeShapes.py

@@ -479,6 +479,12 @@ class ShapeTypeBool(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
     def isKnownToHaveAttribute(attribute_name):
         return hasattr(True, attribute_name)
 
+    def getOperationUnaryAddShape(self):
+        return tshape_int, ControlFlowDescriptionNoEscape
+
+    def getOperationUnarySubShape(self):
+        return tshape_int, ControlFlowDescriptionNoEscape
+
 
 tshape_bool = ShapeTypeBool()
 
@@ -492,6 +498,12 @@ class ShapeTypeInt(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
     def getTypeName():
         return "int"
 
+    if isExperimental("optimize-dual-int"):
+
+        @staticmethod
+        def getCType():
+            return CTypeNuitkaIntOrLongStruct
+
     helper_code = "INT" if python_version < 0x300 else "LONG"
 
     add_shapes = add_shapes_int
@@ -536,6 +548,12 @@ class ShapeTypeInt(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
     def isKnownToHaveAttribute(attribute_name):
         return hasattr(7, attribute_name)
 
+    def getOperationUnaryAddShape(self):
+        return self, ControlFlowDescriptionNoEscape
+
+    def getOperationUnarySubShape(self):
+        return tshape_int_or_long, ControlFlowDescriptionNoEscape
+
 
 tshape_int = ShapeTypeInt()
 
@@ -605,7 +623,7 @@ if python_version < 0x300:
     class ShapeTypeIntOrLong(ShapeNotContainerMixin, ShapeNumberMixin, ShapeBase):
         __slots__ = ()
 
-        if isExperimental("nuitka_ilong"):
+        if isExperimental("optimize-dual-int"):
 
             @staticmethod
             def getCType():
@@ -903,11 +921,11 @@ class ShapeTypeList(ShapeContainerMutableMixin, ShapeNotNumberMixin, ShapeBase):
 
         # Need to consider value shape for this.
         if right_shape in (tshape_list, tshape_tuple):
-            return operation_result_bool_elementbased
+            return operation_result_bool_element_based
 
         if right_shape is tshape_xrange:
             if python_version < 0x300:
-                return operation_result_bool_elementbased
+                return operation_result_bool_element_based
             else:
                 # TODO: Actually unorderable, but this requires making a
                 # difference with "=="
@@ -1693,11 +1711,11 @@ class ShapeTypeXrange(ShapeContainerImmutableMixin, ShapeNotNumberMixin, ShapeBa
         if python_version < 0x300:
             # Need to consider value shape for this.
             if right_shape in (tshape_list, tshape_tuple):
-                return operation_result_bool_elementbased
+                return operation_result_bool_element_based
 
             if right_shape is tshape_xrange:
                 # TODO: This is value escaping, but that doesn't really apply
-                return operation_result_bool_elementbased
+                return operation_result_bool_element_based
         else:
             # TODO: Actually unorderable, but this requires making a
             # difference with "=="
@@ -1908,7 +1926,7 @@ operation_result_dict_noescape = tshape_dict, ControlFlowDescriptionNoEscape
 operation_result_dict_valueerror = tshape_dict, ControlFlowDescriptionValueErrorNoEscape
 
 
-operation_result_bool_elementbased = (
+operation_result_bool_element_based = (
     tshape_bool,
     ControlFlowDescriptionElementBasedEscape,
 )
@@ -1965,7 +1983,6 @@ operation_result_unsupported_matmult = (
     ControlFlowDescriptionMatmultUnsupported,
 )
 
-
 # ZeroDivisionError can occur for some module and division operations, otherwise they
 # are fixed type.
 operation_result_zerodiv_int = tshape_int, ControlFlowDescriptionZeroDivisionNoEscape

nuitka/nodes/shapes/ShapeMixins.py

@@ -6,8 +6,10 @@
 """
 
 from .ControlFlowDescriptions import (
+    ControlFlowDescriptionAddUnsupported,
     ControlFlowDescriptionElementBasedEscape,
     ControlFlowDescriptionNoEscape,
+    ControlFlowDescriptionSubUnsupported,
 )
 
 
@@ -131,10 +133,19 @@ class ShapeNotNumberMixin(object):
     def hasShapeSlotComplex():
         return False
 
+    # TODO: Seems misplaced
     @staticmethod
     def hasShapeModule():
         return False
 
+    @staticmethod
+    def getOperationUnaryAddShape():
+        return None, ControlFlowDescriptionAddUnsupported
+
+    @staticmethod
+    def getOperationUnarySubShape():
+        return None, ControlFlowDescriptionSubUnsupported
+
 
 class ShapeNumberMixin(object):
     """Mixin that defines the number slots to be set."""
@@ -182,6 +193,12 @@ class ShapeNumberMixin(object):
     def getOperationUnaryReprEscape():
         return ControlFlowDescriptionNoEscape
 
+    def getOperationUnaryAddShape(self):
+        return self, ControlFlowDescriptionNoEscape
+
+    def getOperationUnarySubShape(self):
+        return self, ControlFlowDescriptionNoEscape
+
 
 class ShapeIteratorMixin(ShapeNotContainerMixin):
     # Mixins are required to define empty slots

nuitka/nodes/shapes/StandardShapes.py

@@ -8,7 +8,10 @@ from abc import abstractmethod
 from nuitka.code_generation.c_types.CTypePyObjectPointers import (
     CTypePyObjectPtr,
 )
-from nuitka.code_generation.Reports import onMissingOperation
+from nuitka.code_generation.Reports import (
+    onMissingOperation,
+    onMissingUnaryOperation,
+)
 from nuitka.utils.SlotMetaClasses import getMetaClassBase
 
 from .ControlFlowDescriptions import ControlFlowDescriptionFullEscape
@@ -446,6 +449,16 @@ class ShapeBase(getMetaClassBase("Shape", require_slots=True)):
 
             return operation_result_unknown
 
+    def getOperationUnaryAddShape(self):
+        onMissingUnaryOperation("+", self)
+
+        return operation_result_unknown
+
+    def getOperationUnarySubShape(self):
+        onMissingUnaryOperation("-", self)
+
+        return operation_result_unknown
+
     def getComparisonLtShape(self, right_shape):
         onMissingOperation("Lt", self, right_shape)
 
@@ -543,6 +556,12 @@ class ShapeTypeUnknown(ShapeBase):
     def getOperationBinaryMatMultShape(right_shape):
         return operation_result_unknown
 
+    def getOperationUnaryAddShape(self):
+        return operation_result_unknown
+
+    def getOperationUnarySubShape(self):
+        return operation_result_unknown
+
     @staticmethod
     def getComparisonLtShape(right_shape):
         return operation_result_unknown
@@ -650,6 +669,13 @@ class ShapeIterator(ShapeBase, ShapeIteratorMixin):
     def getOperationUnaryReprEscape():
         return ControlFlowDescriptionFullEscape
 
+    def getOperationUnaryAddShape(self):
+        # TODO: Move prepared values to separate module
+        return tshape_unknown, ControlFlowDescriptionFullEscape
+
+    def getOperationUnarySubShape(self):
+        return tshape_unknown, ControlFlowDescriptionFullEscape
+
 
 tshape_iterator = ShapeIterator()
 
@@ -898,6 +924,22 @@ class ShapeLoopInitialAlternative(ShapeBase):
                 ControlFlowDescriptionFullEscape,
             )
 
+    def getOperationUnaryAddShape(self):
+        return (
+            self._collectInitialShape(
+                operation=lambda left_shape: left_shape.getOperationUnaryAddShape()
+            ),
+            ControlFlowDescriptionFullEscape,
+        )
+
+    def getOperationUnarySubShape(self):
+        return (
+            self._collectInitialShape(
+                operation=lambda left_shape: left_shape.getOperationUnarySubShape()
+            ),
+            ControlFlowDescriptionFullEscape,
+        )
+
     def getComparisonLtShape(self, right_shape):
         if right_shape is tshape_unknown:
             return operation_result_unknown
@@ -1162,6 +1204,16 @@ class ShapeLoopCompleteAlternative(ShapeBase):
             )
         )
 
+    def getOperationUnaryAddShape(self):
+        return self._collectShapeOperation(
+            operation=lambda left_shape: left_shape.getOperationUnaryAddShape()
+        )
+
+    def getOperationUnarySubShape(self):
+        return self._collectShapeOperation(
+            operation=lambda left_shape: left_shape.getOperationUnarySubShape()
+        )
+
     # Special method to be called by other shapes encountering this type on
     # the right side.
     def getOperationBinaryAddLShape(self, left_shape):

nuitka/optimizations/BytecodeDemotion.py

@@ -23,6 +23,7 @@ from nuitka.plugins.Plugins import (
     replaceTriggerModule,
 )
 from nuitka.Tracing import inclusion_logger
+from nuitka.utils.FileOperations import getNormalizedPath
 
 
 def demoteSourceCodeToBytecode(module_name, source_code, filename):
@@ -59,7 +60,7 @@ def demoteCompiledModuleToBytecode(module):
     uncompiled_module = makeUncompiledPythonModule(
         module_name=full_name,
         reason=module.reason,
-        filename=filename,
+        filename=getNormalizedPath(filename),
         bytecode=bytecode,
         is_package=module.isCompiledPythonPackage(),
         technical=full_name in detectEarlyImports(),

nuitka/plugins/PluginBase.py

@@ -172,7 +172,11 @@ def _getEvaluationContext():
             # Iterating packages
             "iterate_modules": _iterate_module_names,
             # Locating package directories
-            "_get_module_directory": _getModuleDirectory,
+            "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
@@ -326,6 +330,22 @@ def _getModuleDirectory(module_name):
     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)
@@ -1251,21 +1271,25 @@ 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():
@@ -1283,6 +1307,16 @@ except ImportError:
             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.
@@ -1469,7 +1503,7 @@ except ImportError:
 
                     if info is None:
                         self.sysexit(
-                            "Error, failed to evaluate variables for %s." % full_name
+                            "Error, failed to evaluate variables for '%s'." % full_name
                         )
 
                     variables.update(info.asDict())
@@ -1541,38 +1575,46 @@ except ImportError:
                     raise
 
                 self.sysexit(
-                    "Error, failed to evaluate expression %r in this context, exception was '%s'."
+                    "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.sysexit(
-                    """\
-Error, expression '%s' for module '%s' did not evaluate to 'str' result."""
-                    % (expression, full_name)
+                self._checkStrResult(
+                    value=result, expression=expression, full_name=full_name
                 )
             else:
-                if type(result) not in (tuple, list):
-                    self.sysexit(
-                        """\
-Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' or 'list[str]' result."""
-                        % (expression, full_name)
-                    )
+                self._checkSequenceResult(
+                    value=result, expression=expression, full_name=full_name
+                )
 
                 for v in result:
-                    if type(v) not in (str, unicode):
-                        self.sysexit(
-                            """\
-Error, expression '%s' for module '%s' did not evaluate to 'str', 'tuple[str]' or 'list[str]' result."""
-                            % (expression, full_name)
-                        )
+                    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

nuitka/plugins/Plugins.py

@@ -33,6 +33,7 @@ from nuitka.PythonVersions import python_version
 from nuitka.Tracing import plugins_logger, printLine
 from nuitka.utils.FileOperations import (
     getDllBasename,
+    getNormalizedPath,
     makePath,
     putTextFileContents,
 )
@@ -784,9 +785,11 @@ class Plugins(object):
 
         try:
             trigger_module = buildModule(
-                module_filename=os.path.join(
-                    os.path.dirname(module.getCompileTimeFilename()),
-                    module_name.asPath() + ".py",
+                module_filename=getNormalizedPath(
+                    os.path.join(
+                        os.path.dirname(module.getCompileTimeFilename()),
+                        module_name.asPath() + ".py",
+                    )
                 ),
                 module_name=module_name,
                 reason="trigger",