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

nuitka/code_generation/Contexts.py

@@ -24,7 +24,7 @@ from abc import abstractmethod
 from contextlib import contextmanager
 
 from nuitka import Options
-from nuitka.__past__ import getMetaClassBase, iterItems
+from nuitka.__past__ import iterItems
 from nuitka.Constants import isMutable
 from nuitka.PythonVersions import python_version
 from nuitka.Serialization import ConstantAccessor
@@ -34,6 +34,7 @@ from nuitka.utils.InstanceCounters import (
     counted_init,
     isCountingInstances,
 )
+from nuitka.utils.SlotMetaClasses import getMetaClassBase
 
 from .VariableDeclarations import VariableDeclaration, VariableStorage
 
@@ -44,6 +45,9 @@ class TempMixin(object):
     # Lots of details, everything gets to store bits here, to indicate
     # code generation states, and there are many, pylint: disable=too-many-instance-attributes
 
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
     def __init__(self):
         self.tmp_names = {}
 
@@ -301,6 +305,9 @@ CodeObjectHandle = collections.namedtuple(
 
 
 class CodeObjectsMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
     def __init__(self):
         # Code objects needed made unique by a key.
         self.code_objects = {}
@@ -336,7 +343,9 @@ class CodeObjectsMixin(object):
         return getStringHash("-".join(str(s) for s in key))
 
 
-class PythonContextBase(getMetaClassBase("Context")):
+class PythonContextBase(getMetaClassBase("Context", require_slots=True)):
+    __slots__ = ("source_ref", "current_source_ref")
+
     @counted_init
     def __init__(self):
         self.source_ref = None
@@ -522,6 +531,8 @@ class PythonContextBase(getMetaClassBase("Context")):
 class PythonChildContextBase(PythonContextBase):
     # Base classes can be abstract, pylint: disable=I0021,abstract-method
 
+    __slots__ = ("parent",)
+
     def __init__(self, parent):
         PythonContextBase.__init__(self)
 
@@ -568,6 +579,9 @@ class PythonChildContextBase(PythonContextBase):
 
 
 class FrameDeclarationsMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
     def __init__(self):
         # Frame is active or not, default not.
         self.frame_variables_stack = [""]
@@ -699,6 +713,9 @@ class FrameDeclarationsMixin(object):
 
 
 class ReturnReleaseModeMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
     def __init__(self):
         self.return_release_mode = False
 
@@ -722,6 +739,9 @@ class ReturnReleaseModeMixin(object):
 
 
 class ReturnValueNameMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
     def __init__(self):
         self.return_name = None
 
@@ -738,9 +758,9 @@ class ReturnValueNameMixin(object):
 
 
 class PythonModuleContext(
+    FrameDeclarationsMixin,
     TempMixin,
     CodeObjectsMixin,
-    FrameDeclarationsMixin,
     ReturnReleaseModeMixin,
     ReturnValueNameMixin,
     PythonContextBase,
@@ -748,6 +768,44 @@ class PythonModuleContext(
     # Plenty of attributes, because it's storing so many different things.
     # pylint: disable=too-many-instance-attributes
 
+    __slots__ = (
+        "module",
+        "name",
+        "code_name",
+        "declaration_codes",
+        "helper_codes",
+        "frame_handle",
+        "variable_storage",
+        "function_table_entries",
+        "constant_accessor",
+        # FrameDeclarationsMixin
+        "frame_variables_stack",
+        "frame_type_descriptions",
+        "frame_variable_types",
+        "frames_used",
+        "frame_stack",
+        "locals_dict_names",
+        # TempMixin:
+        "tmp_names",
+        "labels",
+        "exception_escape",
+        "loop_continue",
+        "loop_break",
+        "true_target",
+        "false_target",
+        "keeper_variable_count",
+        "exception_keepers",
+        "preserver_variable_declaration",
+        "cleanup_names",
+        # CodeObjectsMixin
+        "code_objects",
+        # ReturnReleaseModeMixin
+        "return_release_mode",
+        "return_exit",
+        # ReturnValueNameMixin
+        "return_name",
+    )
+
     def __init__(self, module, data_filename):
         PythonContextBase.__init__(self)
 
@@ -857,6 +915,36 @@ class PythonFunctionContext(
     ReturnValueNameMixin,
     PythonChildContextBase,
 ):
+    __slots__ = (
+        "function",
+        "frame_handle",
+        "variable_storage",
+        # FrameDeclarationsMixin
+        "frame_variables_stack",
+        "frame_type_descriptions",
+        "frame_variable_types",
+        "frames_used",
+        "frame_stack",
+        "locals_dict_names",
+        # TempMixin:
+        "tmp_names",
+        "labels",
+        "exception_escape",
+        "loop_continue",
+        "loop_break",
+        "true_target",
+        "false_target",
+        "keeper_variable_count",
+        "exception_keepers",
+        "preserver_variable_declaration",
+        "cleanup_names",
+        # ReturnReleaseModeMixin
+        "return_release_mode",
+        "return_exit",
+        # ReturnValueNameMixin
+        "return_name",
+    )
+
     def __init__(self, parent, function):
         PythonChildContextBase.__init__(self, parent=parent)
 
@@ -902,6 +990,8 @@ class PythonFunctionContext(
 
 
 class PythonFunctionDirectContext(PythonFunctionContext):
+    __slots__ = ()
+
     @staticmethod
     def getContextObjectName():
         return None
@@ -916,6 +1006,8 @@ class PythonFunctionDirectContext(PythonFunctionContext):
 
 
 class PythonGeneratorObjectContext(PythonFunctionContext):
+    __slots__ = ()
+
     def _makeVariableStorage(self):
         return VariableStorage(heap_name="%s_heap" % self.getContextObjectName())
 
@@ -939,18 +1031,24 @@ class PythonGeneratorObjectContext(PythonFunctionContext):
 
 
 class PythonCoroutineObjectContext(PythonGeneratorObjectContext):
+    __slots__ = ()
+
     @staticmethod
     def getContextObjectName():
         return "coroutine"
 
 
 class PythonAsyncgenObjectContext(PythonGeneratorObjectContext):
+    __slots__ = ()
+
     @staticmethod
     def getContextObjectName():
         return "asyncgen"
 
 
 class PythonFunctionCreatedContext(PythonFunctionContext):
+    __slots__ = ()
+
     @staticmethod
     def getContextObjectName():
         return None
@@ -967,6 +1065,16 @@ class PythonFunctionCreatedContext(PythonFunctionContext):
 class PythonFunctionOutlineContext(
     ReturnReleaseModeMixin, ReturnValueNameMixin, PythonChildContextBase
 ):
+    __slots__ = (
+        "outline",
+        "variable_storage",
+        # ReturnReleaseModeMixin
+        "return_release_mode",
+        "return_exit",
+        # ReturnValueNameMixin
+        "return_name",
+    )
+
     def __init__(self, parent, outline):
         PythonChildContextBase.__init__(self, parent=parent)
 

nuitka/code_generation/DictCodes.py

@@ -279,13 +279,14 @@ def generateDictOperationGet2Code(to_name, expression, emit, context):
             renderTemplateFromString(
                 r"""
 {% if expression.known_hashable_key %}
-%(value_name)s = DICT_GET_ITEM0(tstate, %(dict_name)s, %(key_name)s);
+%(value_name)s = DICT_GET_ITEM1(tstate, %(dict_name)s, %(key_name)s);
 if (%(value_name)s == NULL) {
 {% else %}
-%(value_name)s = DICT_GET_ITEM_WITH_HASH_ERROR0(tstate, %(dict_name)s, %(key_name)s);
+%(value_name)s = DICT_GET_ITEM_WITH_HASH_ERROR1(tstate, %(dict_name)s, %(key_name)s);
 if (%(value_name)s == NULL && !HAS_ERROR_OCCURRED(tstate)) {
 {% endif %}
     %(value_name)s = Py_None;
+    Py_INCREF(%(value_name)s);
 }
 """,
                 expression=expression,
@@ -305,15 +306,14 @@ if (%(value_name)s == NULL && !HAS_ERROR_OCCURRED(tstate)) {
             context=context,
         )
 
+        context.addCleanupTempName(value_name)
+
 
 def generateDictOperationGet3Code(to_name, expression, emit, context):
     dict_name, key_name, default_name = generateChildExpressionsCode(
         expression=expression, emit=emit, context=context
     )
 
-    # TODO: This code could actually make it dependent on default taking
-    # a reference or not, and then use DICT_GET_ITEM0/DICT_GET_ITEM_WITH_HASH_ERROR0 if not.
-
     with withObjectCodeTemporaryAssignment(
         to_name, "dict_value", expression, emit, context
     ) as value_name:

nuitka/code_generation/FunctionCodes.py

@@ -213,8 +213,10 @@ def getFunctionMakerCode(
         "constant_return_code": indented(constant_return_code),
     }
 
-    # TODO: Make it optional.
-    context.addFunctionCreationInfo(function_impl_identifier)
+    # TODO: Make it optional, only dill plugin really uses that table to
+    # transport the C code implementation pointers.
+    if function_impl_identifier != "NULL":
+        context.addFunctionCreationInfo(function_impl_identifier)
 
     return result
 

nuitka/code_generation/GlobalConstants.py

@@ -21,6 +21,7 @@
 
 from nuitka import Options
 from nuitka.__past__ import long
+from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonVersions import python_version
 from nuitka.utils.Utils import isWin32Windows
 
@@ -136,6 +137,11 @@ def getConstantDefaultPopulation():
     # "__package__" parsing
     result.append(".")
 
+    # For star imports checking private symbols
+    result.append("_")
+    if python_version < 0x300:
+        result.append("_")
+
     if python_version >= 0x300:
         # Modules have that attribute starting with Python3
         result.append("__loader__")
@@ -218,4 +224,8 @@ def getConstantDefaultPopulation():
     if isWin32Windows():
         result.append("fileno")
 
+    for value in Plugins.getExtraConstantDefaultPopulation():
+        if value not in result:
+            result.append(value)
+
     return result

nuitka/code_generation/ImportCodes.py

@@ -22,7 +22,7 @@ That is import as expression, and star import.
 
 import os
 
-from nuitka.nodes.ImportNodes import hard_modules
+from nuitka.HardImportRegistry import isHardModule, isHardModuleDynamic
 from nuitka.nodes.LocalsScopes import GlobalsDictHandle
 from nuitka.PythonVersions import python_version
 from nuitka.utils.Jinja2 import renderTemplateFromString
@@ -33,7 +33,7 @@ from .CodeHelpers import (
     generateExpressionCode,
     withObjectCodeTemporaryAssignment,
 )
-from .ErrorCodes import getErrorExitBoolCode, getErrorExitCode, getReleaseCode
+from .ErrorCodes import getErrorExitBoolCode, getErrorExitCode
 from .LineNumberCodes import emitLineNumberUpdateCode
 from .ModuleCodes import getModuleAccessCode
 
@@ -131,7 +131,6 @@ def _getBuiltinImportCode(
 
 
 def generateImportModuleFixedCode(to_name, expression, emit, context):
-    module_name = expression.getModuleName()
     needs_check = expression.mayRaiseException(BaseException)
 
     if needs_check:
@@ -141,8 +140,12 @@ def generateImportModuleFixedCode(to_name, expression, emit, context):
         to_name, "imported_value", expression, emit, context
     ) as value_name:
         emit(
-            """%s = IMPORT_MODULE1(tstate, %s);"""
-            % (value_name, context.getConstantCode(module_name.asString()))
+            """%s = IMPORT_MODULE_FIXED(tstate, %s, %s);"""
+            % (
+                value_name,
+                context.getConstantCode(expression.getModuleName().asString()),
+                context.getConstantCode(expression.getValueName().asString()),
+            )
         )
 
         getErrorExitCode(
@@ -151,24 +154,6 @@ def generateImportModuleFixedCode(to_name, expression, emit, context):
 
         context.addCleanupTempName(value_name)
 
-        # IMPORT_MODULE1 doesn't give the child module if one is imported.
-        if "." in module_name:
-            getReleaseCode(value_name, emit, context)
-
-            emit(
-                """%s = Nuitka_GetModule(tstate, %s);"""
-                % (value_name, context.getConstantCode(module_name.asString()))
-            )
-
-            getErrorExitCode(
-                check_name=value_name,
-                needs_check=needs_check,
-                emit=emit,
-                context=context,
-            )
-
-            context.addCleanupTempName(value_name)
-
 
 def getImportModuleHardCodeName(module_name):
     """Encoding hard module name for code name."""
@@ -190,22 +175,44 @@ def generateImportModuleHardCode(to_name, expression, emit, context):
     with withObjectCodeTemporaryAssignment(
         to_name, "imported_value", expression, emit, context
     ) as value_name:
+        import_gives_ref, module_getter_code = getImportHardModuleGetterCode(
+            module_name=imported_module_name, context=context
+        )
+
         if imported_module_name == module_value_name:
-            emit(
-                """%s = %s();"""
-                % (value_name, getImportModuleHardCodeName(imported_module_name))
-            )
+            emit("""%s = %s;""" % (value_name, module_getter_code))
         else:
-            emit("""%s();""" % getImportModuleHardCodeName(imported_module_name))
+            import_gives_ref, module_getter_code2 = getImportHardModuleGetterCode(
+                module_name=module_value_name, context=context
+            )
+
             emit(
-                """%s = %s();"""
-                % (value_name, getImportModuleHardCodeName(module_value_name))
+                renderTemplateFromString(
+                    r"""
+{% if import_gives_ref %}
+{
+    PyObject *hard_module = {{module_getter_code1}};
+    Py_DECREF(hard_module);
+}
+{% else %}
+{{module_getter_code1}};
+{% endif %}
+{{value_name}} = {{module_getter_code2}};
+""",
+                    value_name=value_name,
+                    module_getter_code1=module_getter_code,
+                    module_getter_code2=module_getter_code2,
+                    import_gives_ref=import_gives_ref,
+                )
             )
 
         getErrorExitCode(
             check_name=value_name, needs_check=needs_check, emit=emit, context=context
         )
 
+        if import_gives_ref:
+            context.addCleanupTempName(value_name)
+
 
 def generateConstantSysVersionInfoCode(to_name, expression, emit, context):
     with withObjectCodeTemporaryAssignment(
@@ -218,37 +225,66 @@ def generateConstantSysVersionInfoCode(to_name, expression, emit, context):
     )
 
 
+def getImportHardModuleGetterCode(module_name, context):
+    if isHardModuleDynamic(module_name):
+        module_name_code = context.getConstantCode(module_name.asString())
+
+        module_getter_code = "IMPORT_MODULE_FIXED(tstate, %s, %s)" % (
+            module_name_code,
+            module_name_code,
+        )
+        gives_ref = True
+    else:
+        module_getter_code = "%s()" % getImportModuleHardCodeName(module_name)
+        gives_ref = False
+
+    return gives_ref, module_getter_code
+
+
 def getImportModuleNameHardCode(
     to_name, module_name, import_name, needs_check, emit, context
 ):
     if module_name == "sys":
         emit("""%s = Nuitka_SysGetObject("%s");""" % (to_name, import_name))
         needs_release = False
-    elif module_name in hard_modules:
+    elif isHardModule(module_name):
         if needs_check:
             emitLineNumberUpdateCode(expression=None, emit=emit, context=context)
 
+        import_gives_ref, module_getter_code = getImportHardModuleGetterCode(
+            module_name=module_name, context=context
+        )
+
         emit(
             renderTemplateFromString(
                 r"""
 {
-    PyObject *hard_module = {{module_code_name}}();
+    PyObject *hard_module = {{module_getter_code}};
 {% if needs_check %}
     if (likely(hard_module != NULL)) {
         {{to_name}} = LOOKUP_ATTRIBUTE(tstate, hard_module, {{import_name}});
+
+{% if import_gives_ref %}
+        Py_DECREF(hard_module);
+{% endif %}
+
     } else {
         {{to_name}} = NULL;
     }
 {% else %}
     {{to_name}} = LOOKUP_ATTRIBUTE(tstate, hard_module, {{import_name}});
+{% if import_gives_ref %}
+    Py_DECREF(hard_module);
+{% endif %}
 {% endif %}
 }
 """,
                 to_name=to_name,
                 module_name=str(module_name),
-                module_code_name=getImportModuleHardCodeName(module_name),
+                module_getter_code=module_getter_code,
                 import_name=context.getConstantCode(import_name),
                 needs_check=needs_check,
+                import_gives_ref=import_gives_ref,
             )
         )
 

nuitka/code_generation/ModuleCodes.py

@@ -22,6 +22,7 @@
 from nuitka import Options
 from nuitka.__past__ import iterItems
 from nuitka.code_generation import Emission
+from nuitka.utils.CStrings import encodePythonStringToC
 from nuitka.Version import getNuitkaVersion, getNuitkaVersionYear
 
 from .CodeHelpers import (
@@ -130,7 +131,9 @@ def getModuleCode(
     )
 
     return template % {
-        "module_name": module_name,
+        "module_name_cstr": encodePythonStringToC(
+            module_name.asString().encode("utf8")
+        ),
         "version": getNuitkaVersion(),
         "year": getNuitkaVersionYear(),
         "is_top": 1 if module.isTopModule() else 0,

nuitka/code_generation/Namify.py

@@ -24,13 +24,12 @@ it is really necessary.
 """
 
 
-import hashlib
 import math
 import re
 import sys
 from types import BuiltinFunctionType
 
-from nuitka.__past__ import GenericAlias, UnionType, long, unicode, xrange
+from nuitka.__past__ import GenericAlias, UnionType, long, md5, unicode, xrange
 from nuitka.Builtins import builtin_anon_values, builtin_named_values_list
 from nuitka.Tracing import general
 
@@ -210,6 +209,8 @@ def _namifyString(string):
         return "slash"
     elif string == "\\":
         return "backslash"
+    elif string == "_":
+        return "underscore"
     elif (
         type(string) is str
         and _re_str_needs_no_digest.match(string)
@@ -244,10 +245,10 @@ def _isAscii(string):
 def _digest(value):
     if str is bytes:
         # Python2 is simple
-        return hashlib.md5(value).hexdigest()
+        return md5(value).hexdigest()
     else:
         # Python3 needs to encode the string if it is one.
         if type(value) is bytes:
-            return hashlib.md5(value).hexdigest()
+            return md5(value).hexdigest()
         else:
-            return hashlib.md5(value.encode("utf8")).hexdigest()
+            return md5(value.encode("utf8")).hexdigest()

nuitka/code_generation/YieldCodes.py

@@ -175,7 +175,7 @@ def generateYieldFromCode(to_name, expression, emit, context):
         context.removeCleanupTempName(value_name)
 
     yield_code = """\
-generator->m_yieldfrom = %(yield_from)s;
+generator->m_yield_from = %(yield_from)s;
 return NULL;
 """ % {
         "yield_from": value_name
@@ -195,7 +195,7 @@ return NULL;
         )
 
 
-def generateYieldFromWaitableCode(to_name, expression, emit, context):
+def generateYieldFromAwaitableCode(to_name, expression, emit, context):
     # In handlers, we must preserve/restore the exception.
     preserve_exception = expression.isExceptionPreserving()
 
@@ -204,7 +204,7 @@ def generateYieldFromWaitableCode(to_name, expression, emit, context):
     )
 
     yield_code = """\
-%(object_name)s->m_yieldfrom = %(yield_from)s;
+%(object_name)s->m_yield_from = %(yield_from)s;
 %(object_name)s->m_awaiting = true;
 return NULL;
 """ % {