Nuitka-winsvc 2.2.3__cp311-cp311-win_amd64.whl → 2.3.2__cp311-cp311-win_amd64.whl

nuitka/code_generation/templates_c/HelperOperationComparisonTuple.c.j2

@@ -1,6 +1,6 @@
 {#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file #}
 
-static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()}}_{{left.getHelperCodeName()}}_{{right.getHelperCodeName()}}({{left.getVariableDecl("operand1")}}, {{right.getVariableDecl("operand2")}}) {
+static {{ target.getTypeDecl() }} COMPARE_{{op_code}}_{{target.getHelperCodeName()}}_{{left.getHelperCodeName()}}_{{right.getHelperCodeName()}}({{left.getVariableDecl("operand1")}}, {{right.getVariableDecl("operand2")}}) {
     {{left.getCheckValueCode("operand1")}}
     {{right.getCheckValueCode("operand2")}}
 
@@ -20,8 +20,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
 {% endif %}
 
         // Convert to target type.
-        {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r")}};
-        {{target.getTakeReferenceStatement("result")}}
+        {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r")}};
+        {{ target.getTakeReferenceStatement("result", immortal=True) }}
         return result;
     }
 {% endif %}
@@ -61,8 +61,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
         bool r = len_a {{operand}} len_b;
 
         // Convert to target type.
-        {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r")}};
-        {{target.getTakeReferenceStatement("result")}}
+        {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r")}};
+        {{ target.getTakeReferenceStatement("result", immortal=True) }}
         return result;
     }
 
@@ -75,8 +75,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
 {% endif %}
 
     // Convert to target type.
-    {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r")}};
-    {{target.getTakeReferenceStatement("result")}}
+    {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r")}};
+    {{ target.getTakeReferenceStatement("result", immortal=True) }}
     return result;
 
 {% endif %}

nuitka/code_generation/templates_c/HelperOperationComparisonUnicode.c.j2

@@ -1,6 +1,6 @@
 {#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file #}
 
-static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()}}_{{left.getHelperCodeName()}}_{{right.getHelperCodeName()}}({{left.getVariableDecl("operand1")}}, {{right.getVariableDecl("operand2")}}) {
+static {{ target.getTypeDecl() }} COMPARE_{{op_code}}_{{target.getHelperCodeName()}}_{{left.getHelperCodeName()}}_{{right.getHelperCodeName()}}({{left.getVariableDecl("operand1")}}, {{right.getVariableDecl("operand2")}}) {
     {{left.getCheckValueCode("operand1")}}
     {{right.getCheckValueCode("operand2")}}
 
@@ -16,8 +16,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
 {% endif %}
 
         // Convert to target type.
-        {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r")}};
-        {{target.getTakeReferenceStatement("result")}}
+        {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r")}};
+        {{ target.getTakeReferenceStatement("result", immortal=True) }}
         return result;
     }
 
@@ -60,8 +60,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
         }
     }
 
-    {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r == " + ("true" if operand == "==" else "false"))}};
-    {{target.getTakeReferenceStatement("result")}}
+    {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r == " + ("true" if operand == "==" else "false"))}};
+    {{ target.getTakeReferenceStatement("result", immortal=True) }}
     return result;
 #else
     bool r;
@@ -77,8 +77,8 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
         r = (cmp == 0);
     }
 
-    {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r == " + ("true" if operand == "==" else "false"))}};
-    {{target.getTakeReferenceStatement("result")}}
+    {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r == " + ("true" if operand == "==" else "false"))}};
+    {{ target.getTakeReferenceStatement("result", immortal=True) }}
     return result;
 #endif
 {% else %}
@@ -91,9 +91,9 @@ static {{target.getTypeDecl()}} COMPARE_{{op_code}}_{{target.getHelperCodeName()
     return r;
 {% else %}
     // Convert to target type if necessary
-    {{target.getTypeDecl()}} result = {{target.getToValueFromBoolExpression("r == Py_True")}};
-    Py_DECREF(r);
-    {{target.getTakeReferenceStatement("result")}}
+    {{ target.getTypeDecl() }} result = {{target.getToValueFromBoolExpression("r == Py_True")}};
+    Py_DECREF_IMMORTAL(r);
+    {{ target.getTakeReferenceStatement("result", immortal=True) }}
     return result;
 {% endif %}
 {% endif %}

nuitka/code_generation/templates_c/HelperOperationInplace.c.j2

@@ -23,7 +23,7 @@
             {{ goto_exit(props, "exit_inplace_result_object", "x") }}
         }
 
-        Py_DECREF(x);
+        Py_DECREF_IMMORTAL(x);
     }
 {% else %}
     // No inplace number slot {{ nb_inplace_slot }} available for this type.

nuitka/code_generation/templates_c/HelperSlotsBinary.c.j2

@@ -171,7 +171,7 @@
                     {{ goto_exit(props, exit_result_object, "x") }}
                 }
 
-                Py_DECREF(x);
+                Py_DECREF_IMMORTAL(x);
                 slot2 = NULL;
             }
         }
@@ -183,7 +183,7 @@
             {{ goto_exit(props, exit_result_object, "x") }}
         }
 
-        Py_DECREF(x);
+        Py_DECREF_IMMORTAL(x);
     }
 {% endif %}
 
@@ -195,7 +195,7 @@
             {{ goto_exit(props, exit_result_object, "x") }}
         }
 
-        Py_DECREF(x);
+        Py_DECREF_IMMORTAL(x);
     }
 {% endif %}
 

nuitka/code_generation/templates_c/HelperSlotsList.c.j2

@@ -9,7 +9,10 @@
     {# TODO: Could and should in-line and specialize this per slot too. #}
 {% if nb_slot == "nb_add" %}
 {% if left.type_name == "list" == right.type_name %}
-    PyObject *x = LIST_CONCAT({{ operand1 }}, {{ operand2 }});
+    // TODO: Have this more globally passed in
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *x = LIST_CONCAT(tstate, {{ operand1 }}, {{ operand2 }});
 {% else %}
     PyObject *x = {{ left.getSlotCallExpression("sq_concat", "PyList_Type.tp_as_sequence->sq_concat", operand1, operand2) }};
 {% endif %}

nuitka/code_generation/templates_c/HelperSlotsTuple.c.j2

@@ -9,7 +9,10 @@
     {# TODO: Could and should in-line and specialize this per slot too. #}
 {% if nb_slot == "nb_add" %}
 {% if left.type_name == "tuple" == right.type_name %}
-    PyObject *x = TUPLE_CONCAT({{ operand1 }}, {{ operand2 }});
+    // TODO: Have this more globally passed in
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyObject *x = TUPLE_CONCAT(tstate, {{ operand1 }}, {{ operand2 }});
 {% else %}
     PyObject *x = {{ left.getSlotCallExpression("sq_concat", "PyTuple_Type.tp_as_sequence->sq_concat", operand1, operand2) }};
 {% endif %}

nuitka/finalizations/FinalizeMarkups.py

@@ -18,17 +18,9 @@ are in another context.
 """
 
 from nuitka import Tracing
-from nuitka.__past__ import unicode
-from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.PythonVersions import python_version
 from nuitka.tree.Operations import VisitorNoopMixin
 
-imported_names = OrderedSet()
-
-
-def getImportedNames():
-    return imported_names
-
 
 class FinalizeMarkups(VisitorNoopMixin):
     def onEnterNode(self, node):
@@ -66,16 +58,6 @@ class FinalizeMarkups(VisitorNoopMixin):
                 else:
                     search.markAsNeedsGeneratorReturnHandling(1)
 
-        if node.isExpressionBuiltinImport() and node.follow_attempted:
-            module_name = node.subnode_name
-
-            if module_name.isCompileTimeConstant():
-                imported_module_name = module_name.getCompileTimeConstant()
-
-                if type(imported_module_name) in (str, unicode):
-                    if imported_module_name:
-                        imported_names.add(imported_module_name)
-
         if node.isExpressionFunctionCreation():
             if (
                 not node.getParent().isExpressionFunctionCall()

nuitka/freezer/DependsExe.py

@@ -20,6 +20,7 @@ from nuitka.utils.FileOperations import (
     getFileContentByLine,
     getWindowsLongPathName,
     isFilenameBelowPath,
+    isFilesystemEncodable,
     putTextFileContents,
     withFileLock,
 )
@@ -160,10 +161,14 @@ def parseDependsExeOutput(filename):
 
 
 def detectDLLsWithDependencyWalker(binary_filename, source_dir, scan_dirs):
-    dwp_filename = os.path.join(source_dir, os.path.basename(binary_filename) + ".dwp")
-    output_filename = os.path.join(
-        source_dir, os.path.basename(binary_filename) + ".depends"
-    )
+    source_dir = getExternalUsePath(source_dir)
+    temp_base_name = os.path.basename(binary_filename)
+
+    if not isFilesystemEncodable(temp_base_name):
+        temp_base_name = "dependency_walker"
+
+    dwp_filename = os.path.join(source_dir, temp_base_name + ".dwp")
+    output_filename = os.path.join(source_dir, temp_base_name + ".depends")
 
     # User query should only happen once if at all.
     with withFileLock(

nuitka/freezer/DllDependenciesMacOS.py

@@ -175,7 +175,7 @@ def _resolveBinaryPathDLLsMacOS(
                     resolved_path = os.path.normpath(os.path.join(rpath, path[7:]))
                     break
             else:
-                # These have become virtual in later macOS.
+                # These have become virtual in later macOS, spell-checker: ignore libz
                 if library_name in ("libc++.1.dylib", "libz.1.dylib"):
                     continue
 

nuitka/freezer/DllDependenciesWin32.py

@@ -100,7 +100,7 @@ def _getScanDirectories(package_name, original_dir):
     if cache_key in _scan_dir_cache:
         return _scan_dir_cache[cache_key]
 
-    scan_dirs = [getSystemPrefixPath()]
+    scan_dirs = [os.path.dirname(sys.executable), getSystemPrefixPath()]
 
     if package_name is not None:
         scan_dirs.extend(getPackageSpecificDLLDirectories(package_name))

nuitka/freezer/ImportDetection.py

@@ -210,6 +210,7 @@ def _detectEarlyImports():
         "base64_codec",
         "hex_codec",
         "rot_13",
+        "punycode",
     ):
         if non_locale_encoding in encoding_names:
             encoding_names.remove(non_locale_encoding)

nuitka/freezer/IncludedDataFiles.py

@@ -227,13 +227,22 @@ def makeIncludedDataDirectory(
     ignore_suffixes=(),
     only_suffixes=(),
     normalize=True,
+    raw=False,
 ):
     assert isRelativePath(dest_path), dest_path
     assert os.path.isdir(source_path), source_path
 
-    ignore_dirs = tuple(ignore_dirs) + default_ignored_dirs
-    ignore_filenames = tuple(ignore_filenames) + default_ignored_filenames
-    ignore_suffixes = tuple(ignore_suffixes) + default_ignored_suffixes
+    ignore_dirs = tuple(ignore_dirs)
+    if not raw:
+        ignore_dirs += default_ignored_dirs
+
+    ignore_filenames = tuple(ignore_filenames)
+    if not raw:
+        ignore_filenames += default_ignored_filenames
+
+    ignore_suffixes = tuple(ignore_suffixes)
+    if not raw:
+        ignore_suffixes += default_ignored_suffixes
 
     for filename in getFileList(
         source_path,
@@ -255,7 +264,7 @@ def makeIncludedDataDirectory(
             tags=tags,
         )
 
-        included_datafile.tags.add("data-dir-contents")
+        included_datafile.tags.add("raw-dir-contents" if raw else "data-dir-contents")
 
         yield included_datafile
 

nuitka/freezer/IncludedEntryPoints.py

@@ -229,6 +229,13 @@ def addIncludedEntryPoint(entry_point):
             if areSamePaths(
                 entry_point.source_path, standalone_entry_point.source_path
             ):
+                if (
+                    standalone_entry_point.kind == "extension"
+                    and entry_point.kind == "dll"
+                ):
+                    entry_point = _makeIgnoredEntryPoint(entry_point)
+                    break
+
                 return
 
             if isShowInclusion():
@@ -325,6 +332,15 @@ def addExtensionModuleEntryPoint(module):
     )
 
 
+def getIncludedExtensionModule(source_path):
+    for standalone_entry_point in standalone_entry_points:
+        if standalone_entry_point.kind == "extension":
+            if areSamePaths(source_path, standalone_entry_point.source_path):
+                return standalone_entry_point
+
+    return None
+
+
 def getStandaloneEntryPoints():
     return tuple(standalone_entry_points)
 

nuitka/freezer/Onefile.py

@@ -61,7 +61,6 @@ def _runOnefileScons(onefile_compression, onefile_archive):
     Plugins.writeExtraCodeFiles(onefile=True)
 
     options = {
-        "result_name": OutputDirectories.getResultBasePath(onefile=True),
         "result_exe": OutputDirectories.getResultFullpath(onefile=True),
         "source_dir": source_dir,
         "debug_mode": asBoolStr(Options.is_debug),

nuitka/freezer/Standalone.py

@@ -49,7 +49,11 @@ from .DllDependenciesMacOS import (
 )
 from .DllDependenciesPosix import detectBinaryPathDLLsPosix
 from .DllDependenciesWin32 import detectBinaryPathDLLsWin32
-from .IncludedEntryPoints import addIncludedEntryPoint, makeDllEntryPoint
+from .IncludedEntryPoints import (
+    addIncludedEntryPoint,
+    getIncludedExtensionModule,
+    makeDllEntryPoint,
+)
 
 
 def checkFreezingModuleSet():
@@ -241,7 +245,7 @@ def _reduceToPythonPath(used_dlls):
 def _detectUsedDLLs(standalone_entry_point, source_dir):
     binary_filename = standalone_entry_point.source_path
     try:
-        used_dlls = _detectBinaryDLLs(
+        used_dll_paths = _detectBinaryDLLs(
             is_main_executable=standalone_entry_point.kind == "executable",
             source_dir=source_dir,
             original_filename=standalone_entry_point.source_path,
@@ -251,12 +255,14 @@ def _detectUsedDLLs(standalone_entry_point, source_dir):
             update_cache=not shallNotStoreDependsExeCachedResults(),
         )
     except NuitkaForbiddenDLLEncounter:
-        inclusion_logger.info("Not including forbidden DLL '%s'." % binary_filename)
+        inclusion_logger.info(
+            "Not including due to forbidden DLL '%s'." % binary_filename
+        )
     else:
         # Plugins generally decide if they allow dependencies from the outside
         # based on the package name.
 
-        if standalone_entry_point.module_name is not None and used_dlls:
+        if standalone_entry_point.module_name is not None and used_dll_paths:
             module_name, module_filename, _kind, finding = locateModule(
                 standalone_entry_point.module_name, parent_package=None, level=0
             )
@@ -275,35 +281,46 @@ def _detectUsedDLLs(standalone_entry_point, source_dir):
                 )
 
             if allow_outside_dependencies is False:
-                used_dlls = _reduceToPythonPath(used_dlls)
+                used_dll_paths = _reduceToPythonPath(used_dll_paths)
 
         # Allow plugins can prevent inclusion, this may discard things from used_dlls.
         removed_dlls = Plugins.removeDllDependencies(
-            dll_filename=binary_filename, dll_filenames=used_dlls
+            dll_filename=binary_filename, dll_filenames=used_dll_paths
         )
-        used_dlls = tuple(OrderedSet(used_dlls) - OrderedSet(removed_dlls))
-
-        for used_dll in used_dlls:
-            dest_path = os.path.basename(used_dll)
-
-            # TODO: If used by a DLL from the same folder, put it there,
-            # otherwise top level, but for now this is limited to a few cases
-            # where required that way (openvino) or known to be good only (av),
-            # because it broke other things. spell-checker: ignore openvino
-            if standalone_entry_point.package_name in (
-                "openvino",
-                "av",
-            ) and areInSamePaths(standalone_entry_point.source_path, used_dll):
+        used_dll_paths = tuple(OrderedSet(used_dll_paths) - OrderedSet(removed_dlls))
+
+        for used_dll_path in used_dll_paths:
+            extension_standalone_entry_point = getIncludedExtensionModule(used_dll_path)
+            if extension_standalone_entry_point is not None:
+                # Sometimes an extension module is used like a DLL, make sure to
+                # remove it as a DLL then, there is no value in keeping those. Need
+                # to keep it's destination path from that extension module then.
+                dest_path = extension_standalone_entry_point.dest_path
+            elif (
+                standalone_entry_point.package_name is not None
+                and standalone_entry_point.package_name.hasOneOfNamespaces(
+                    "openvino",
+                    "av",
+                )
+                and areInSamePaths(standalone_entry_point.source_path, used_dll_path)
+            ):
+                # TODO: If used by a DLL from the same folder, put it there,
+                # otherwise top level, but for now this is limited to a few cases
+                # where required that way (openvino) or known to be good only (av),
+                # because it broke other things. spell-checker: ignore openvino
+
                 dest_path = os.path.normpath(
                     os.path.join(
                         os.path.dirname(standalone_entry_point.dest_path),
-                        dest_path,
+                        os.path.basename(used_dll_path),
                     )
                 )
+            else:
+                dest_path = os.path.basename(used_dll_path)
 
             dll_entry_point = makeDllEntryPoint(
                 logger=inclusion_logger,
-                source_path=used_dll,
+                source_path=used_dll_path,
                 dest_path=dest_path,
                 module_name=standalone_entry_point.module_name,
                 package_name=standalone_entry_point.package_name,

nuitka/importing/ImportCache.py

@@ -14,6 +14,7 @@ not start anew, but reuse what we already found out about it.
 import os
 
 from nuitka.plugins.Plugins import Plugins
+from nuitka.utils.Importing import hasPackageDirFilename
 
 imported_modules = {}
 imported_by_name = {}
@@ -22,7 +23,7 @@ imported_by_name = {}
 def addImportedModule(imported_module):
     module_filename = os.path.abspath(imported_module.getFilename())
 
-    if os.path.basename(module_filename) == "__init__.py":
+    if hasPackageDirFilename(module_filename):
         module_filename = os.path.dirname(module_filename)
 
     key = (module_filename, imported_module.getFullName())
@@ -55,7 +56,7 @@ def getImportedModuleByNameAndPath(full_name, module_filename):
     # For caching we use absolute paths only.
     module_filename = os.path.abspath(module_filename)
 
-    if os.path.basename(module_filename) == "__init__.py":
+    if hasPackageDirFilename(module_filename):
         module_filename = os.path.dirname(module_filename)
 
     # KeyError is valid result.

nuitka/importing/Importing.py

@@ -41,6 +41,7 @@ from nuitka.utils.Hashing import getFileContentsHash
 from nuitka.utils.Importing import (
     builtin_module_names,
     getModuleFilenameSuffixes,
+    getPackageDirFilename,
     getSharedLibrarySuffixes,
     isBuiltinModuleName,
 )
@@ -228,6 +229,16 @@ def getModuleNameAndKindFromFilename(module_filename):
             )
 
     if os.path.isdir(module_filename):
+        package_filename = getPackageDirFilename(module_filename)
+
+        if package_filename is not None:
+            for suffix in getSharedLibrarySuffixes():
+                if package_filename.endswith(suffix):
+                    return (
+                        ModuleName(os.path.basename(module_filename)),
+                        "extension",
+                    )
+
         return ModuleName(os.path.basename(module_filename)), "py"
 
     return None, None
@@ -507,9 +518,6 @@ def _findModuleInPath2(package_name, module_name, search_path):
             found = False
 
             for suffix, module_type in getModuleFilenameSuffixes():
-                if module_type == "C_EXTENSION":
-                    continue
-
                 package_file_name = "__init__" + suffix
 
                 file_path = os.path.join(package_directory, package_file_name)
@@ -1016,6 +1024,11 @@ _stdlib_module_raises = {
     "zlib": False,
     "_ssl": True,
     "_xxinterpchannels": False,
+    # TODO: 3.13 clarify if this is actually true
+    "_interpchannels": False,
+    "_interpreters": False,
+    "_interpqueues": False,
+    "_sysconfig": False,
 }
 
 

nuitka/importing/StandardLibrary.py

@@ -18,6 +18,7 @@ from nuitka.PythonVersions import python_version
 from nuitka.utils.FileOperations import getFileContents, isFilenameBelowPath
 from nuitka.utils.ModuleNames import ModuleName
 from nuitka.utils.Utils import (
+    isMacOS,
     isNetBSD,
     isPosixWindows,
     isWin32OrPosixWindows,
@@ -175,6 +176,9 @@ def scanStandardLibraryPath(stdlib_dir):
             if "ensurepip" in dirs:
                 dirs.remove("ensurepip")
 
+            if "_ios_support.py" in filenames and not isMacOS():
+                filenames.remove("_ios_support.py")
+
             # Ignore "lib-dynload" and "lib-tk" and alike.
             dirs[:] = [
                 dirname

nuitka/nodes/ChildrenHavingMixins.py

@@ -13853,6 +13853,7 @@ class ChildHavingPathMixin(object):
     #   ExpressionOsPathExists
     #   ExpressionOsPathIsdir
     #   ExpressionOsPathIsfile
+    #   ExpressionOsPathNormpath
 
     def __init__(
         self,
@@ -13939,6 +13940,7 @@ ChildrenExpressionOsPathAbspathMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathExistsMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathIsdirMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathIsfileMixin = ChildHavingPathMixin
+ChildrenExpressionOsPathNormpathMixin = ChildHavingPathMixin
 
 
 class ChildHavingPathOptionalMixin(object):

nuitka/nodes/ExpressionBasesGenerated.py

@@ -206,6 +206,7 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 
     # This is generated for use in
     #   ExpressionBuiltinMakeExceptionImportError
+    #   ExpressionBuiltinMakeExceptionModuleNotFoundError
 
     def __init__(self, args, name, path, source_ref):
         assert type(args) is tuple
@@ -390,6 +391,9 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 ExpressionBuiltinMakeExceptionImportErrorBase = (
     ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin
 )
+ExpressionBuiltinMakeExceptionModuleNotFoundErrorBase = (
+    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin
+)
 
 
 class ChildrenHavingCallableArgSentinelFinalMixin(ExpressionBase):

nuitka/nodes/HardImportNodesGenerated.py

@@ -63,6 +63,7 @@ from nuitka.specs.HardImportSpecs import (
     os_path_isabs_spec,
     os_path_isdir_spec,
     os_path_isfile_spec,
+    os_path_normpath_spec,
     os_uname_spec,
     pkg_resources_get_distribution_spec,
     pkg_resources_iter_entry_points_spec,
@@ -2489,6 +2490,88 @@ class ExpressionOsPathIsfileCallBase(ChildHavingPathMixin, ExpressionBase):
         return True
 
 
+class ExpressionOsPathNormpathRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference os.path.normpath"""
+
+    kind = "EXPRESSION_OS_PATH_NORMPATH_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name=os.path.__name__,
+            import_name="normpath",
+            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 .OsSysNodes import ExpressionOsPathNormpathCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionOsPathNormpathCall,
+            builtin_spec=os_path_normpath_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'os.path.normpath' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionOsPathNormpathRef] = os_path_normpath_spec
+
+
+class ExpressionOsPathNormpathCallBase(ChildHavingPathMixin, ExpressionBase):
+    """Base class for OsPathNormpathCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = ("path",)
+
+    __slots__ = ("attempted",)
+
+    spec = os_path_normpath_spec
+
+    def __init__(self, path, source_ref):
+
+        ChildHavingPathMixin.__init__(
+            self,
+            path=path,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.attempted = False
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not os_path_normpath_spec.isCompileTimeComputable(
+            (self.subnode_path,)
+        ):
+            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 ExpressionOsUnameRef(ExpressionImportModuleNameHardExistsSpecificBase):
     """Function reference os.uname"""