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

nuitka/build/static_src/MetaPathBasedLoader.c

@@ -166,8 +166,26 @@ NUITKA_MAY_BE_UNUSED static PyObject *MAKE_RELATIVE_PATH_FROM_NAME(char const *n
     return result;
 }
 
-static PyObject *loadModuleFromCodeObject(PyObject *module, PyCodeObject *code_object, char const *name,
-                                          bool is_package) {
+static PyObject *_makeDunderPathObject(PyThreadState *tstate, PyObject *module_path_entry) {
+    CHECK_OBJECT(module_path_entry);
+
+    PyObject *path_list = MAKE_LIST_EMPTY(tstate, 1);
+    if (unlikely(path_list == NULL)) {
+        return NULL;
+    }
+
+    int res = PyList_SetItem(path_list, 0, module_path_entry);
+    if (unlikely(res != 0)) {
+        return NULL;
+    }
+    Py_INCREF(module_path_entry);
+
+    CHECK_OBJECT(path_list);
+    return path_list;
+}
+
+static PyObject *loadModuleFromCodeObject(PyThreadState *tstate, PyObject *module, PyCodeObject *code_object,
+                                          char const *name, bool is_package) {
     assert(code_object != NULL);
 
     {
@@ -200,20 +218,9 @@ static PyObject *loadModuleFromCodeObject(PyObject *module, PyCodeObject *code_o
 
     if (is_package) {
         /* Set __path__ properly, unlike frozen module importer does. */
-        NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
-
-        PyObject *path_list = MAKE_LIST_EMPTY(tstate, 1);
-        if (unlikely(path_list == NULL)) {
-            return NULL;
-        }
+        PyObject *path_list = _makeDunderPathObject(tstate, module_path_entry);
 
-        int res = PyList_SetItem(path_list, 0, module_path_entry);
-        if (unlikely(res != 0)) {
-            return NULL;
-        }
-        Py_INCREF(module_path_entry);
-
-        res = PyObject_SetAttr(module, const_str_plain___path__, path_list);
+        int res = PyObject_SetAttr(module, const_str_plain___path__, path_list);
         if (unlikely(res != 0)) {
             return NULL;
         }
@@ -461,7 +468,8 @@ static bool scanModuleInPackagePath(PyThreadState *tstate, PyObject *module_name
     return result;
 }
 
-static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const filename_char_t *filename);
+static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const filename_char_t *filename,
+                                         bool is_package);
 
 static PyObject *callIntoInstalledExtensionModule(PyThreadState *tstate, PyObject *module_name,
                                                   PyObject *extension_module_filename) {
@@ -479,7 +487,9 @@ static PyObject *callIntoInstalledExtensionModule(PyThreadState *tstate, PyObjec
     char const *extension_module_filename_str = Nuitka_String_AsString(extension_module_filename);
 #endif
 
-    return callIntoExtensionModule(tstate, Nuitka_String_AsString(module_name), extension_module_filename_str);
+    // TODO: The value of "is_package" is guessed, maybe infer from filename being
+    // a "__init__.so" and the like.
+    return callIntoExtensionModule(tstate, Nuitka_String_AsString(module_name), extension_module_filename_str, false);
 }
 
 #endif
@@ -675,8 +685,27 @@ static void _fillExtensionModuleDllEntryFunctionName(PyThreadState *tstate, char
 #endif
 }
 
-static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name,
-                                         const filename_char_t *filename) {
+#ifdef _NUITKA_STANDALONE
+// Append the the entry name from full path module name with dots,
+// and translate these into directory separators.
+static void _makeModuleCFilenameValue(filename_char_t *filename, size_t filename_size, char const *module_name_cstr,
+                                      PyObject *module_name) {
+#ifdef _WIN32
+    appendWStringSafeW(filename, getBinaryDirectoryWideChars(true), filename_size);
+    appendCharSafeW(filename, SEP, filename_size);
+    appendModuleNameAsPathW(filename, module_name, filename_size);
+    appendStringSafeW(filename, ".pyd", filename_size);
+#else
+    appendStringSafe(filename, getBinaryDirectoryHostEncoded(true), filename_size);
+    appendCharSafe(filename, SEP, filename_size);
+    appendModuleNameAsPath(filename, module_name_cstr, filename_size);
+    appendStringSafe(filename, ".so", filename_size);
+#endif
+}
+#endif
+
+static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full_name, const filename_char_t *filename,
+                                         bool is_package) {
     // Determine the package name and basename of the module to load.
     char const *dot = strrchr(full_name, '.');
     char const *name;
@@ -836,7 +865,10 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
 
         PyObject *full_name_obj = Nuitka_String_FromString(full_name);
 
-        PyObject *spec_value = createModuleSpec(tstate, full_name_obj, NULL, false);
+        PyObject *origin = Nuitka_String_FromFilename(filename);
+
+        PyObject *spec_value = createModuleSpec(tstate, full_name_obj, origin, is_package);
+        CHECK_OBJECT(spec_value);
 
         module = PyModule_FromDefAndSpec(def, spec_value);
 
@@ -848,16 +880,25 @@ static PyObject *callIntoExtensionModule(PyThreadState *tstate, char const *full
             return NULL;
         }
 
-        setModuleFileValue(tstate, module, filename);
-        PyObject_SetAttrString((PyObject *)spec_value, "origin",
-                               LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__));
         SET_ATTRIBUTE(tstate, module, const_str_plain___spec__, spec_value);
 
+        setModuleFileValue(tstate, module, filename);
+
+        /* Set __path__ properly, unlike frozen module importer does. */
+        PyObject *path_list = _makeDunderPathObject(tstate, origin);
+
+        int res = PyObject_SetAttr(module, const_str_plain___path__, path_list);
+        if (unlikely(res != 0)) {
+            return NULL;
+        }
+
+        Py_DECREF(path_list);
+
         Nuitka_SetModule(full_name_obj, module);
         Py_DECREF(full_name_obj);
 
         SET_ATTRIBUTE(tstate, spec_value, const_str_plain__initializing, Py_True);
-        int res = PyModule_ExecDef(module, def);
+        res = PyModule_ExecDef(module, def);
         SET_ATTRIBUTE(tstate, spec_value, const_str_plain__initializing, Py_False);
 
         Py_DECREF(spec_value);
@@ -1011,35 +1052,22 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
                             struct Nuitka_MetaPathBasedLoaderEntry const *entry) {
 #ifdef _NUITKA_STANDALONE
     if ((entry->flags & NUITKA_EXTENSION_MODULE_FLAG) != 0) {
-        // Append the the entry name from full path module name with dots,
-        // and translate these into directory separators.
-#ifdef _WIN32
-        wchar_t filename[MAXPATHLEN + 1] = {0};
-
-        appendWStringSafeW(filename, getBinaryDirectoryWideChars(true), sizeof(filename) / sizeof(wchar_t));
-        appendCharSafeW(filename, SEP, sizeof(filename) / sizeof(wchar_t));
-        appendModuleNameAsPathW(filename, module_name, sizeof(filename) / sizeof(wchar_t));
-        appendStringSafeW(filename, ".pyd", sizeof(filename) / sizeof(wchar_t));
-#else
-        char filename[MAXPATHLEN + 1] = {0};
-
-        appendStringSafe(filename, getBinaryDirectoryHostEncoded(true), sizeof(filename));
-        appendCharSafe(filename, SEP, sizeof(filename));
-        appendModuleNameAsPath(filename, entry->name, sizeof(filename));
-        appendStringSafe(filename, ".so", sizeof(filename));
-
-#endif
+        filename_char_t filename[MAXPATHLEN + 1] = {0};
+        _makeModuleCFilenameValue(filename, sizeof(filename) / sizeof(filename_char_t), entry->name, module_name);
 
         // Set "__spec__" and "__file__", some modules expect it early.
         setModuleFileValue(tstate, module, filename);
+
+        bool is_package = (entry->flags & NUITKA_PACKAGE_FLAG) != 0;
+
 #if PYTHON_VERSION >= 0x350
-        PyObject *spec_value =
-            createModuleSpec(tstate, module_name, LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__), false);
+        PyObject *spec_value = createModuleSpec(tstate, module_name,
+                                                LOOKUP_ATTRIBUTE(tstate, module, const_str_plain___file__), is_package);
 
         SET_ATTRIBUTE(tstate, module, const_str_plain___spec__, spec_value);
 #endif
 
-        callIntoExtensionModule(tstate, entry->name, filename);
+        callIntoExtensionModule(tstate, entry->name, filename, is_package);
     } else
 #endif
         if ((entry->flags & NUITKA_BYTECODE_FLAG) != 0) {
@@ -1055,7 +1083,8 @@ static PyObject *loadModule(PyThreadState *tstate, PyObject *module, PyObject *m
             abort();
         }
 
-        return loadModuleFromCodeObject(module, code_object, entry->name, (entry->flags & NUITKA_PACKAGE_FLAG) != 0);
+        return loadModuleFromCodeObject(tstate, module, code_object, entry->name,
+                                        (entry->flags & NUITKA_PACKAGE_FLAG) != 0);
     } else {
         assert((entry->flags & NUITKA_EXTENSION_MODULE_FLAG) == 0);
         assert(entry->python_initfunc);

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -149,16 +149,7 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
         return NULL;
     }
 
-    PyObject *code_object_desc = MAKE_TUPLE_EMPTY(tstate, 6);
-    PyTuple_SET_ITEM0(code_object_desc, 0, function->m_code_object->co_filename);
-    PyTuple_SET_ITEM0(code_object_desc, 1, function->m_code_object->co_name);
-    PyTuple_SET_ITEM(code_object_desc, 2, PyLong_FromLong(function->m_code_object->co_firstlineno));
-    PyTuple_SET_ITEM0(code_object_desc, 3, function->m_code_object->co_varnames);
-    PyTuple_SET_ITEM(code_object_desc, 4, PyLong_FromLong(function->m_code_object->co_argcount));
-    PyTuple_SET_ITEM(code_object_desc, 5, PyLong_FromLong(function->m_code_object->co_flags));
-
-    CHECK_OBJECT_DEEP(code_object_desc);
-
+    PyObject *code_object_desc = Nuitka_Function_ExtractCodeObjectDescription(tstate, function);
 
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, 8);
     PyTuple_SET_ITEM(result, 0, PyLong_FromLong(offset));

nuitka/freezer/DllDependenciesCommon.py

@@ -8,6 +8,7 @@ import os
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.importing.Importing import locateModule
 from nuitka.plugins.Plugins import Plugins
+from nuitka.Tracing import inclusion_logger
 from nuitka.utils.FileOperations import getSubDirectoriesWithDlls
 from nuitka.utils.ModuleNames import ModuleName
 
@@ -22,7 +23,12 @@ def getLdLibraryPath(package_name, python_rpaths, original_dir):
         if python_rpaths:
             ld_library_path.update(python_rpaths)
 
-        ld_library_path.update(getPackageSpecificDLLDirectories(package_name))
+        ld_library_path.update(
+            getPackageSpecificDLLDirectories(
+                package_name=package_name,
+                consider_plugins=True,
+            )
+        )
         if original_dir is not None:
             ld_library_path.add(original_dir)
 
@@ -31,7 +37,9 @@ def getLdLibraryPath(package_name, python_rpaths, original_dir):
     return _ld_library_cache[key]
 
 
-def getPackageSpecificDLLDirectories(package_name, consider_plugins=True):
+def getPackageSpecificDLLDirectories(
+    package_name, consider_plugins, allow_not_found=False
+):
     scan_dirs = OrderedSet()
 
     if package_name is not None:
@@ -39,6 +47,17 @@ def getPackageSpecificDLLDirectories(package_name, consider_plugins=True):
             module_name=package_name, parent_package=None, level=0
         )[1]
 
+        if package_dir is None:
+            if allow_not_found:
+                return scan_dirs
+
+            inclusion_logger.sysexit(
+                """\
+Error, failed to locate package '%s' while trying to look up DLL dependencies, \
+that should not happen. Please report the issue."""
+                % package_name
+            )
+
         if os.path.isdir(package_dir):
             scan_dirs.add(package_dir)
             scan_dirs.update(getSubDirectoriesWithDlls(package_dir))
@@ -51,7 +70,13 @@ def getPackageSpecificDLLDirectories(package_name, consider_plugins=True):
 
     # TODO: Move this to plugins DLLs section.
     if package_name == "torchvision" and consider_plugins:
-        scan_dirs.update(getPackageSpecificDLLDirectories(ModuleName("torch")))
+        scan_dirs.update(
+            getPackageSpecificDLLDirectories(
+                package_name=ModuleName("torch"),
+                consider_plugins=True,
+                allow_not_found=True,
+            )
+        )
 
     return scan_dirs
 

nuitka/freezer/DllDependenciesWin32.py

@@ -103,7 +103,12 @@ def _getScanDirectories(package_name, original_dir):
     scan_dirs = [os.path.dirname(sys.executable), getSystemPrefixPath()]
 
     if package_name is not None:
-        scan_dirs.extend(getPackageSpecificDLLDirectories(package_name))
+        scan_dirs.extend(
+            getPackageSpecificDLLDirectories(
+                package_name=package_name,
+                consider_plugins=False,
+            )
+        )
 
     if original_dir is not None:
         scan_dirs.append(original_dir)

nuitka/importing/Importing.py

@@ -599,7 +599,11 @@ def _findModuleInPath2(package_name, module_name, search_path):
     if (
         found_candidate.module_type == "C_EXTENSION"
         and isMacOS()
-        and not hasUniversalOrMatchingMacOSArchitecture(found_candidate.full_path)
+        and not hasUniversalOrMatchingMacOSArchitecture(
+            getPackageDirFilename(found_candidate.full_path)
+            if os.path.isdir(found_candidate.full_path)
+            else found_candidate.full_path
+        )
     ):
         # Not usable for target architecture.
         raise ImportError

nuitka/nodes/ModuleNodes.py

@@ -20,7 +20,7 @@ from nuitka.PythonVersions import python_version
 from nuitka.SourceCodeReferences import fromFilename
 from nuitka.tree.SourceHandling import parsePyIFile, readSourceCodeFromFilename
 from nuitka.utils.CStrings import encodePythonIdentifierToC
-from nuitka.utils.Importing import getSharedLibrarySuffix
+from nuitka.utils.Importing import getPackageDirFilename
 from nuitka.utils.ModuleNames import ModuleName
 
 from .ChildrenHavingMixins import (
@@ -1008,9 +1008,8 @@ class PythonExtensionModule(PythonModuleBase):
         self.used_modules = None
 
         if os.path.isdir(module_filename):
-            module_filename = os.path.join(
-                module_filename, "__init__" + getSharedLibrarySuffix(preferred=False)
-            )
+            module_filename = getPackageDirFilename(module_filename)
+
         self.module_filename = module_filename
 
     def finalize(self):

nuitka/plugins/PluginBase.py

@@ -52,7 +52,11 @@ from nuitka.Options import (
     shallMakeModule,
     shallShowExecutedCommands,
 )
-from nuitka.PythonFlavors import isAnacondaPython, isDebianPackagePython
+from nuitka.PythonFlavors import (
+    isAnacondaPython,
+    isDebianPackagePython,
+    isNuitkaPython,
+)
 from nuitka.PythonVersions import (
     getTestExecutionPythonVersions,
     python_version,
@@ -131,6 +135,7 @@ def _getEvaluationContext():
             "anaconda": isAnacondaPython(),
             "is_conda_package": isDistributionCondaPackage,
             "debian_python": isDebianPackagePython(),
+            "nuitka_python": isNuitkaPython(),
             "standalone": isStandaloneMode(),
             "module_mode": shallMakeModule(),
             "deployment": isDeploymentMode(),
@@ -195,8 +200,11 @@ def _getEvaluationContext():
         _context_dict["before_python3"] = python_version < 0x300
         _context_dict["python3_or_higher"] = python_version >= 0x300
 
-        _context_dict["extension_std_suffix"] = getSharedLibrarySuffix(preferred=True)
-        _context_dict["extension_suffix"] = getSharedLibrarySuffix(preferred=False)
+        if not isNuitkaPython():
+            _context_dict["extension_std_suffix"] = getSharedLibrarySuffix(
+                preferred=True
+            )
+            _context_dict["extension_suffix"] = getSharedLibrarySuffix(preferred=False)
 
     return _context_dict
 

nuitka/plugins/standard/KivyPlugin.py

@@ -6,6 +6,7 @@
 
 from nuitka.Options import isStandaloneMode
 from nuitka.plugins.PluginBase import NuitkaPluginBase
+from nuitka.utils.Utils import isMacOS, isWin32Windows
 
 
 class NuitkaPluginKivy(NuitkaPluginBase):
@@ -88,10 +89,19 @@ except ImportError:
             yield "kivy.graphics.cgl_backend"
         elif full_name == "kivy.graphics.cgl_backend":
             yield "kivy.graphics.cgl_backend.cgl_glew"
+            yield "kivy.graphics.cgl_backend.cgl_sdl2"
         elif full_name == "kivy.graphics.cgl_backend.cgl_glew":
             yield "kivy.graphics.cgl_backend.cgl_gl"
         elif full_name == "kivymd.app":
             yield self.locateModules("kivymd.uix")
+        elif full_name == "kivy.core.clipboard":
+            if isWin32Windows():
+                yield "kivy.core.clipboard.clipboard_winctypes"
+            if isMacOS():
+                if self.locateModule("pyobjus"):
+                    yield "kivy.core.clipboard.clipboard_nspaste"
+                else:
+                    yield "kivy.core.clipboard.clipboard_sdl2"
 
     def getExtraDlls(self, module):
         """Copy extra shared libraries or data for this installation.