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

nuitka/nodes/FunctionNodes.py

@@ -86,11 +86,8 @@ class ExpressionFunctionBodyBase(
         "flags",
     )
 
-    if python_version >= 0x340:
-        __slots__ += ("qualname_provider",)
-
     if python_version >= 0x300:
-        __slots__ += ("non_local_declarations",)
+        __slots__ += ("qualname_provider", "non_local_declarations")
 
     # Might be None initially in some cases.
     named_children = ("body|optional+setter",)
@@ -118,13 +115,12 @@ class ExpressionFunctionBodyBase(
         # officially a child yet. Important during building.
         self.parent = provider
 
-        # Python3.4: Might be overridden by global statement on the class name.
-        # TODO: Make this class only code.
-        if python_version >= 0x340:
+        if python_version >= 0x300:
+            # Python3: Might be overridden by global statement on the class name.
+            # TODO: Make this class only code.
             self.qualname_provider = provider
 
-        # Non-local declarations.
-        if python_version >= 0x300:
+            # Non-local declarations if any.
             self.non_local_declarations = None
 
     @staticmethod
@@ -571,7 +567,7 @@ class ExpressionFunctionBody(
         "parameters",
     )
 
-    if python_version >= 0x340:
+    if python_version >= 0x300:
         __slots__ += ("qualname_setup",)
 
     def __init__(
@@ -583,6 +579,7 @@ class ExpressionFunctionBody(
         parameters,
         flags,
         auto_release,
+        code_prefix,
         source_ref,
     ):
         ExpressionFunctionEntryPointBase.__init__(
@@ -590,7 +587,7 @@ class ExpressionFunctionBody(
             provider=provider,
             name=name,
             code_object=code_object,
-            code_prefix="function",
+            code_prefix=code_prefix,
             flags=flags,
             auto_release=auto_release,
             source_ref=source_ref,
@@ -612,7 +609,7 @@ class ExpressionFunctionBody(
         # Indicator if the function is used outside of where it's defined.
         self.cross_module_use = False
 
-        if python_version >= 0x340:
+        if python_version >= 0x300:
             self.qualname_setup = None
 
         self.parameters = parameters
@@ -779,6 +776,7 @@ class ExpressionFunctionPureBody(ExpressionFunctionBody):
         parameters,
         flags,
         auto_release,
+        code_prefix,
         source_ref,
     ):
         ExpressionFunctionBody.__init__(
@@ -790,6 +788,7 @@ class ExpressionFunctionPureBody(ExpressionFunctionBody):
             parameters=parameters,
             flags=flags,
             auto_release=auto_release,
+            code_prefix=code_prefix,
             source_ref=source_ref,
         )
 

nuitka/nodes/FutureSpecs.py

@@ -24,6 +24,9 @@ _future_annotations_default = python_version >= 0x400
 
 
 class FutureSpec(object):
+    # We are using a bunch of flags here, Python decides them and then we add
+    # even more modes ourselves, pylint: disable=too-many-instance-attributes
+
     __slots__ = (
         "future_division",
         "unicode_literals",
@@ -32,10 +35,11 @@ class FutureSpec(object):
         "barry_bdfl",
         "generator_stop",
         "future_annotations",
+        "use_annotations",
     )
 
     @counted_init
-    def __init__(self):
+    def __init__(self, use_annotations):
         self.future_division = _future_division_default
         self.unicode_literals = False
         self.absolute_import = _future_absolute_import_default
@@ -44,6 +48,9 @@ class FutureSpec(object):
         self.generator_stop = _future_generator_stop_default
         self.future_annotations = _future_annotations_default
 
+        # Attaching our special modes here still.
+        self.use_annotations = use_annotations
+
     if isCountingInstances():
         __del__ = counted_del()
 
@@ -51,7 +58,7 @@ class FutureSpec(object):
         return "<FutureSpec %s>" % ",".join(self.asFlags())
 
     def clone(self):
-        result = FutureSpec()
+        result = FutureSpec(use_annotations=self.use_annotations)
 
         result.future_division = self.future_division
         result.unicode_literals = self.unicode_literals
@@ -96,6 +103,9 @@ class FutureSpec(object):
     def enableFutureAnnotations(self):
         self.future_annotations = True
 
+    def shallUseAnnotations(self):
+        return self.use_annotations
+
     def isFutureAnnotations(self):
         return self.future_annotations
 
@@ -137,7 +147,10 @@ def fromFlags(flags):
     if "" in flags:
         flags.remove("")
 
-    result = FutureSpec()
+    # TODO: For persistence, that's not very good, but it's actually only using
+    # our "no_annotations" flag during building phase, which is completed here,
+    # but we might have to add it in the future to XML differently.
+    result = FutureSpec(use_annotations=False)
 
     if "CO_FUTURE_DIVISION" in flags:
         result.enableFutureDivision()

nuitka/nodes/GeneratorNodes.py

@@ -70,7 +70,7 @@ class ExpressionGeneratorObjectBody(
         "qualname_provider",
     )
 
-    if python_version >= 0x340:
+    if python_version >= 0x300:
         __slots__ += ("qualname_setup",)
 
     def __init__(self, provider, name, code_object, flags, auto_release, source_ref):
@@ -91,7 +91,7 @@ class ExpressionGeneratorObjectBody(
 
         self.trace_collection = None
 
-        if python_version >= 0x340:
+        if python_version >= 0x300:
             self.qualname_setup = None
 
     def getFunctionName(self):

nuitka/nodes/HardImportNodesGenerated.py

@@ -10,18 +10,18 @@
 
 WARNING, this code is GENERATED. Modify the template HardImportReferenceNode.py.j2 instead!
 
-spell-checker: ignore __prepare__ append args autograph buffering capitalize casefold
-spell-checker: ignore center chars clear closefd copy count decode default delete dist
-spell-checker: ignore distribution_name encode encoding end endswith errors exit_code
-spell-checker: ignore expandtabs experimental_attributes experimental_autograph_options
+spell-checker: ignore __prepare__ append args autograph capitalize casefold center chars
+spell-checker: ignore clear copy count decode default delete dist distribution_name encode
+spell-checker: ignore encoding end endswith errors exit_code expandtabs
+spell-checker: ignore experimental_attributes experimental_autograph_options
 spell-checker: ignore experimental_compile experimental_follow_type_hints
-spell-checker: ignore experimental_implements experimental_relax_shapes extend file
-spell-checker: ignore fillchar find format format_map formatmap fromkeys func get group
-spell-checker: ignore handle has_key haskey index input_signature insert isalnum isalpha
-spell-checker: ignore isascii isdecimal isdigit isidentifier islower isnumeric isprintable
-spell-checker: ignore isspace istitle isupper item items iterable iteritems iterkeys
-spell-checker: ignore itervalues jit_compile join keepends key keys kwargs ljust lower
-spell-checker: ignore lstrip maketrans maxsplit mode name new newline old opener p package
+spell-checker: ignore experimental_implements experimental_relax_shapes extend fillchar
+spell-checker: ignore find format format_map formatmap fromkeys func get group handle
+spell-checker: ignore has_key haskey index input_signature insert isalnum isalpha isascii
+spell-checker: ignore isdecimal isdigit isidentifier islower isnumeric isprintable isspace
+spell-checker: ignore istitle isupper item items iterable iteritems iterkeys itervalues
+spell-checker: ignore jit_compile join keepends key keys kwargs ljust lower lstrip
+spell-checker: ignore maketrans maxsplit mode name new old p package
 spell-checker: ignore package_or_requirement pairs partition path pop popitem prefix
 spell-checker: ignore prepare reduce_retracing remove replace resource resource_name
 spell-checker: ignore reverse rfind rindex rjust rpartition rsplit rstrip s sep setdefault
@@ -37,7 +37,6 @@ from nuitka.Options import shallMakeModule
 from nuitka.PythonVersions import python_version
 from nuitka.specs.BuiltinParameterSpecs import extractBuiltinArgs
 from nuitka.specs.HardImportSpecs import (
-    builtins_open_since_3_spec,
     ctypes_cdll_before_38_spec,
     ctypes_cdll_since_38_spec,
     importlib_metadata_backport_distribution_spec,
@@ -86,7 +85,6 @@ from .ChildrenHavingMixins import (
     ChildHavingPMixin,
     ChildHavingRequirementsTupleMixin,
     ChildHavingSMixin,
-    ChildrenHavingFileModeOptionalBufferingOptionalEncodingOptionalErrorsOptionalNewlineOptionalClosefdOptionalOpenerOptionalMixin,
     ChildrenHavingFuncOptionalInputSignatureOptionalAutographOptionalJitCompileOptionalReduceRetracingOptionalExperimentalImplementsOptionalExperimentalAutographOptionsOptionalExperimentalAttributesOptionalExperimentalRelaxShapesOptionalExperimentalCompileOptionalExperimentalFollowTypeHintsOptionalMixin,
     ChildrenHavingGroupNameOptionalMixin,
     ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalMixin,
@@ -107,127 +105,6 @@ from .ImportHardNodes import ExpressionImportModuleNameHardExistsSpecificBase
 hard_import_node_classes = {}
 
 
-class ExpressionBuiltinsOpenRef(ExpressionImportModuleNameHardExistsSpecificBase):
-    """Function reference builtins.open"""
-
-    kind = "EXPRESSION_BUILTINS_OPEN_REF"
-
-    def __init__(self, source_ref):
-        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
-            self,
-            module_name="builtins",
-            import_name="open",
-            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 .BuiltinOpenNodes import makeExpressionBuiltinsOpenCall
-
-        result = extractBuiltinArgs(
-            node=call_node,
-            builtin_class=makeExpressionBuiltinsOpenCall,
-            builtin_spec=builtins_open_since_3_spec,
-        )
-
-        return (
-            result,
-            "new_expression",
-            "Call to 'builtins.open' recognized.",
-        )
-
-
-hard_import_node_classes[ExpressionBuiltinsOpenRef] = builtins_open_since_3_spec
-
-
-class ExpressionBuiltinsOpenCallBase(
-    ChildrenHavingFileModeOptionalBufferingOptionalEncodingOptionalErrorsOptionalNewlineOptionalClosefdOptionalOpenerOptionalMixin,
-    ExpressionBase,
-):
-    """Base class for BuiltinsOpenCall
-
-    Generated boiler plate code.
-    """
-
-    named_children = (
-        "file",
-        "mode|optional",
-        "buffering|optional",
-        "encoding|optional",
-        "errors|optional",
-        "newline|optional",
-        "closefd|optional",
-        "opener|optional",
-    )
-
-    __slots__ = ("attempted",)
-
-    spec = builtins_open_since_3_spec
-
-    def __init__(
-        self,
-        file,
-        mode,
-        buffering,
-        encoding,
-        errors,
-        newline,
-        closefd,
-        opener,
-        source_ref,
-    ):
-
-        ChildrenHavingFileModeOptionalBufferingOptionalEncodingOptionalErrorsOptionalNewlineOptionalClosefdOptionalOpenerOptionalMixin.__init__(
-            self,
-            file=file,
-            mode=mode,
-            buffering=buffering,
-            encoding=encoding,
-            errors=errors,
-            newline=newline,
-            closefd=closefd,
-            opener=opener,
-        )
-
-        ExpressionBase.__init__(self, source_ref)
-
-        self.attempted = False
-
-    def computeExpression(self, trace_collection):
-        if self.attempted or not builtins_open_since_3_spec.isCompileTimeComputable(
-            (
-                self.subnode_file,
-                self.subnode_mode,
-                self.subnode_buffering,
-                self.subnode_encoding,
-                self.subnode_errors,
-                self.subnode_newline,
-                self.subnode_closefd,
-                self.subnode_opener,
-            )
-        ):
-            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 ExpressionCtypesCdllRef(ExpressionImportModuleNameHardExistsSpecificBase):
     """Function reference ctypes.CDLL"""
 

nuitka/nodes/LocalsScopes.py

@@ -5,7 +5,6 @@
 
 from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.Errors import NuitkaOptimizationError
-from nuitka.PythonVersions import python_version
 from nuitka.utils.InstanceCounters import (
     counted_del,
     counted_init,
@@ -24,9 +23,9 @@ def getLocalsDictType(kind):
         locals_scope = LocalsDictExecHandle
     elif kind == "python_function":
         locals_scope = LocalsDictFunctionHandle
-    elif kind == "python3_class":
+    elif kind == "python_mapping_class":
         locals_scope = LocalsMappingHandle
-    elif kind == "python2_class":
+    elif kind == "python_dict_class":
         locals_scope = LocalsDictHandle
     elif kind == "module_dict":
         locals_scope = GlobalsDictHandle
@@ -347,23 +346,22 @@ class LocalsDictHandle(LocalsDictHandleBase):
 
         self.markForLocalsDictPropagation()
 
+    @staticmethod
+    def setTypeShape(type_shape):
+        pass
+
 
 class LocalsMappingHandle(LocalsDictHandle):
     """Locals dict of a Python3 class with a mapping."""
 
-    __slots__ = ("type_shape",)
-
-    # TODO: Removable condition once Python 3.3 support is dropped.
-    if python_version >= 0x340:
-        __slots__ += ("prevented_propagation",)
+    __slots__ = ("type_shape", "prevented_propagation")
 
     def __init__(self, locals_name, owner):
         LocalsDictHandle.__init__(self, locals_name=locals_name, owner=owner)
 
         self.type_shape = tshape_unknown
 
-        if python_version >= 0x340:
-            self.prevented_propagation = False
+        self.prevented_propagation = False
 
     def getTypeShape(self):
         # TODO: Make mapping available for this.
@@ -375,22 +373,20 @@ class LocalsMappingHandle(LocalsDictHandle):
     def hasShapeDictionaryExact(self):
         return self.type_shape is tshape_dict
 
-    if python_version >= 0x340:
-
-        def markAsComplete(self, trace_collection):
-            # For this run, it cannot be done yet.
-            if self.prevented_propagation:
-                # False alarm, this is available.
-                self.prevented_propagation = False
-                return
+    def markAsComplete(self, trace_collection):
+        # For this run, it cannot be done yet.
+        if self.prevented_propagation:
+            # False alarm, this is available.
+            self.prevented_propagation = False
+            return
 
-            self.complete = True
+        self.complete = True
 
-        def preventLocalsDictPropagation(self):
-            self.prevented_propagation = True
+    def preventLocalsDictPropagation(self):
+        self.prevented_propagation = True
 
-        def isPreventedPropagation(self):
-            return self.prevented_propagation
+    def isPreventedPropagation(self):
+        return self.prevented_propagation
 
     def _considerPropagation(self, trace_collection):
         if not self.variables:

nuitka/nodes/MatchNodes.py

@@ -3,26 +3,31 @@
 
 """ Nodes for match statement for Python3.10+ """
 
-from .ChildrenHavingMixins import ChildHavingExpressionMixin
+from .ChildrenHavingMixins import ChildrenHavingExpressionMatchTypeMixin
 from .ExpressionBases import ExpressionBase
 from .ExpressionShapeMixins import ExpressionTupleShapeExactMixin
 
 
 class ExpressionMatchArgs(
-    ExpressionTupleShapeExactMixin, ChildHavingExpressionMixin, ExpressionBase
+    ExpressionTupleShapeExactMixin,
+    ChildrenHavingExpressionMatchTypeMixin,
+    ExpressionBase,
 ):
     kind = "EXPRESSION_MATCH_ARGS"
 
-    named_children = ("expression",)
+    named_children = ("expression", "match_type")
 
-    __slots__ = ("max_allowed",)
+    __slots__ = ("positional_count", "keywords")
 
-    def __init__(self, expression, max_allowed, source_ref):
-        ChildHavingExpressionMixin.__init__(self, expression=expression)
+    def __init__(self, expression, match_type, max_allowed, keywords, source_ref):
+        ChildrenHavingExpressionMatchTypeMixin.__init__(
+            self, expression=expression, match_type=match_type
+        )
 
         ExpressionBase.__init__(self, source_ref)
 
-        self.max_allowed = max_allowed
+        self.positional_count = max_allowed
+        self.keywords = tuple(keywords)
 
     def computeExpression(self, trace_collection):
         # TODO: May know that match args doesn't raise from the shape of
@@ -32,6 +37,12 @@ class ExpressionMatchArgs(
 
         return self, None, None
 
+    def getPositionalArgsCount(self):
+        return self.positional_count
+
+    def getKeywordArgs(self):
+        return self.keywords
+
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.

nuitka/nodes/ModuleAttributeNodes.py

@@ -16,7 +16,7 @@ quickly, in others they will present boundaries for optimization.
 from nuitka import Options
 
 from .ConstantRefNodes import makeConstantRefNode
-from .ExpressionBases import ExpressionBase, ExpressionNoSideEffectsMixin
+from .ExpressionBases import ExpressionBase
 
 
 class ExpressionModuleAttributeBase(ExpressionBase):
@@ -164,25 +164,6 @@ class ExpressionModuleAttributeSpecRef(ExpressionModuleAttributeBase):
         return self, None, None
 
 
-class ExpressionNuitkaLoaderCreation(ExpressionNoSideEffectsMixin, ExpressionBase):
-    __slots__ = ("provider",)
-
-    kind = "EXPRESSION_NUITKA_LOADER_CREATION"
-
-    def __init__(self, provider, source_ref):
-        ExpressionBase.__init__(self, source_ref)
-
-        self.provider = provider
-
-    def finalize(self):
-        del self.parent
-        del self.provider
-
-    def computeExpressionRaw(self, trace_collection):
-        # Nothing can be done here.
-        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/ModuleNodes.py

@@ -202,6 +202,10 @@ class PythonModuleBase(NodeBase):
 
             return result
 
+    @staticmethod
+    def isExtensionModulePackage():
+        return False
+
 
 class CompiledPythonModule(
     ModuleChildrenHavingBodyOptionalStatementsOrNoneFunctionsTupleMixin,
@@ -972,7 +976,7 @@ class PythonMainModule(CompiledPythonModule):
 class PythonExtensionModule(PythonModuleBase):
     kind = "PYTHON_EXTENSION_MODULE"
 
-    __slots__ = ("used_modules", "module_filename", "technical")
+    __slots__ = ("used_modules", "module_filename", "technical", "is_package")
 
     avoid_duplicates = set()
 
@@ -1009,9 +1013,15 @@ class PythonExtensionModule(PythonModuleBase):
 
         if os.path.isdir(module_filename):
             module_filename = getPackageDirFilename(module_filename)
+            self.is_package = True
+        else:
+            self.is_package = False
 
         self.module_filename = module_filename
 
+    def isExtensionModulePackage(self):
+        return self.is_package
+
     def finalize(self):
         del self.used_modules
 
@@ -1026,24 +1036,31 @@ class PythonExtensionModule(PythonModuleBase):
         """Must be present as it's used in CPython library initialization."""
         return self.technical
 
-    def getPyIFilename(self):
+    def _getPyIFilename(self):
         """Get Python type description filename."""
 
         path = self.getFilename()
         filename = os.path.basename(path)
         dirname = os.path.dirname(path)
 
-        return os.path.join(dirname, filename.split(".")[0]) + ".pyi"
+        for suffix in (".pyi", ".py"):
+            candidate = os.path.join(dirname, filename.split(".")[0]) + suffix
+
+            if os.path.exists(candidate):
+                return candidate
+
+        return None
 
     def _readPyIFile(self):
         """Read the .pyi file if present and scan for dependencies."""
 
         if self.used_modules is None:
-            pyi_filename = self.getPyIFilename()
+            pyi_filename = self._getPyIFilename()
 
-            if os.path.exists(pyi_filename):
+            if pyi_filename is not None:
                 pyi_deps = parsePyIFile(
-                    module_name=self.getFullName(), pyi_filename=pyi_filename
+                    module_name=self.getFullName(),
+                    pyi_filename=pyi_filename,
                 )
 
                 # These are not to be taken serious.

nuitka/nodes/NodeBases.py

@@ -319,8 +319,9 @@ class NodeBase(NodeMetaClassBase):
         # For overload by module nodes
         return False
 
-    def isExpressionBuiltin(self):
-        return self.kind.startswith("EXPRESSION_BUILTIN_")
+    @staticmethod
+    def isExpressionBuiltin():
+        return False
 
     @staticmethod
     def isStatementAssignmentVariable():
@@ -495,17 +496,18 @@ class CodeNodeMixin(object):
             provider = self.getParentVariableProvider().getEntryPoint()
             parent_name = provider.getCodeName()
 
-            uid = "_%d" % provider.getChildUID(self)
-
-            assert isinstance(self, CodeNodeMixin)
-
-            if self.name:
-                name = uid + "_" + self.name.strip("<>")
+            if self.code_prefix == "helper_function":
+                name = self.name
             else:
-                name = uid
+                uid = "_%d" % provider.getChildUID(self)
+
+                if self.name:
+                    name = uid + "_" + self.name.strip("<>")
+                else:
+                    name = uid
 
-            if str is not bytes:
-                name = name.encode("ascii", "c_identifier").decode()
+                if str is not bytes:
+                    name = name.encode("ascii", "c_identifier").decode()
 
             self.code_name = "%s$$$%s_%s" % (parent_name, self.code_prefix, name)
 

nuitka/nodes/NodeMetaClasses.py

@@ -36,6 +36,16 @@ def _checkBases(name, bases):
             raise NuitkaNodeDesignError(name, "All bases must set __slots__.", base)
 
 
+@staticmethod
+def returnTrueShared():
+    return True
+
+
+@staticmethod
+def returnFalseShared():
+    return False
+
+
 class NodeCheckMetaClass(ABCMeta):
     kinds = {}
 
@@ -113,22 +123,28 @@ class NodeCheckMetaClass(ABCMeta):
 
             # Automatically add checker methods for everything to the common
             # base class
-            checker_method = "is" + kind_to_name_part
-
-            # TODO: How about making these two functions, one to statically
-            # return True and False, and put one in the base class, and one
-            # in the new class, would be slightly faster.
-            def checkKind(self):
-                return self.kind == kind
+            checker_method_name = "is" + kind_to_name_part
 
-            # Add automatic checker methods to the node base class.
+            # Add automatic checker "False" to the node base class.
             from .NodeBases import NodeBase
 
-            if not hasattr(NodeBase, checker_method):
-                setattr(NodeBase, checker_method, checkKind)
+            if not hasattr(NodeBase, checker_method_name):
+                setattr(NodeBase, checker_method_name, returnFalseShared)
 
         ABCMeta.__init__(cls, name, bases, dictionary)
 
+        if not name.endswith(("Base", "Mixin")):
+            if kind.startswith("EXPRESSION_BUILTIN_"):
+                cls.isExpressionBuiltin = returnTrueShared
+
+            # Add automatic checker "True" to the node class.
+            if getattr(cls, checker_method_name) is returnFalseShared.__func__:
+
+                def checkKind(self):
+                    return self.kind == kind
+
+                setattr(cls, checker_method_name, checkKind)
+
 
 # For every node type, there is a test, and then some more members,
 

nuitka/nodes/ReturnNodes.py

@@ -212,7 +212,7 @@ class StatementReturnReturnedValue(StatementBase):
 
     @staticmethod
     def getStatementNiceName():
-        return "rereturn statement"
+        return "re-return statement"
 
 
 def makeStatementReturnConstant(constant, source_ref):