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

nuitka/plugins/PluginBase.py

@@ -33,7 +33,6 @@ import os
 import sys
 
 from nuitka import Options
-from nuitka.__past__ import getMetaClassBase
 from nuitka.containers.Namedtuples import makeNamedtupleClass
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.freezer.IncludedDataFiles import (
@@ -68,8 +67,16 @@ from nuitka.PythonVersions import (
     python_version,
 )
 from nuitka.Tracing import plugins_logger
-from nuitka.utils.Distributions import isDistributionCondaPackage
+from nuitka.utils.Distributions import (
+    getDistributionFromModuleName,
+    getDistributionName,
+    isDistributionCondaPackage,
+)
 from nuitka.utils.Execution import NuitkaCalledProcessError, check_output
+from nuitka.utils.FileOperations import (
+    changeFilenameExtension,
+    getFileContents,
+)
 from nuitka.utils.Importing import isBuiltinModuleName
 from nuitka.utils.ModuleNames import (
     ModuleName,
@@ -78,8 +85,10 @@ from nuitka.utils.ModuleNames import (
     pre_module_load_trigger_name,
 )
 from nuitka.utils.SharedLibraries import locateDLL, locateDLLsInDirectory
+from nuitka.utils.SlotMetaClasses import getMetaClassBase
 from nuitka.utils.Utils import (
     getArchitecture,
+    isAndroidBasedLinux,
     isLinux,
     isMacOS,
     isWin32Windows,
@@ -112,6 +121,13 @@ def _getPackageNameFromDistributionName(distribution_name):
         return distribution_name
 
 
+def _getDistributionNameFromPackageName(package_name):
+    distribution = getDistributionFromModuleName(package_name)
+
+    assert distribution is not None, package_name
+    return getDistributionName(distribution)
+
+
 def _getPackageVersion(distribution_name):
     if distribution_name not in _package_versions:
         try:
@@ -163,7 +179,7 @@ def _isPluginActive(plugin_name):
     return plugin_name in getUserActivatedPluginNames()
 
 
-class NuitkaPluginBase(getMetaClassBase("Plugin")):
+class NuitkaPluginBase(getMetaClassBase("Plugin", require_slots=False)):
     """Nuitka base class for all plugins.
 
     Derive your plugin from "NuitkaPluginBase" please.
@@ -273,7 +289,7 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
         # Virtual method, pylint: disable=no-self-use,unused-argument
         return ()
 
-    def onModuleSourceCode(self, module_name, source_code):
+    def onModuleSourceCode(self, module_name, source_filename, source_code):
         """Inspect or modify source code.
 
         Args:
@@ -286,6 +302,7 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
             going to allow simply checking the source code without the need to
             pass it back.
         """
+        # Virtual method, pylint: disable=unused-argument
         self.checkModuleSourceCode(module_name, source_code)
 
         return source_code
@@ -431,6 +448,25 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
         # Virtual method, pylint: disable=no-self-use,unused-argument
         return None
 
+    def onModuleUsageLookAhead(
+        self, module_name, module_filename, module_kind, get_module_source
+    ):
+        """React to tentative recursion of a module coming up.
+
+        For definite usage, use onModuleRecursion where it's a fact and
+        happening next. This may be a usage that is later optimized away
+        and doesn't impact anything. The main usage is to setup e.g.
+        hard imports as a factory, e.g. with detectable lazy loaders.
+
+        Args:
+            module_name: full module name
+            module_filename: filename
+            module_kind: one of "py", "extension" (shared library)
+            get_module_source: callable to get module source code if any
+        Returns:
+            None
+        """
+
     def onModuleRecursion(
         self,
         module_name,
@@ -440,7 +476,7 @@ class NuitkaPluginBase(getMetaClassBase("Plugin")):
         source_ref,
         reason,
     ):
-        """React to recursion to a module coming up.
+        """React to recursion of a module coming up.
 
         Args:
             module_name: full module name
@@ -555,22 +591,28 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
         """
         return locateDLLsInDirectory(directory)
 
-    def makeDllEntryPoint(self, source_path, dest_path, package_name, reason):
+    def makeDllEntryPoint(
+        self, source_path, dest_path, module_name, package_name, reason
+    ):
         """Create an entry point, as expected to be provided by getExtraDlls."""
         return makeDllEntryPoint(
             logger=self,
             source_path=source_path,
             dest_path=dest_path,
+            module_name=module_name,
             package_name=package_name,
             reason=reason,
         )
 
-    def makeExeEntryPoint(self, source_path, dest_path, package_name, reason):
+    def makeExeEntryPoint(
+        self, source_path, dest_path, module_name, package_name, reason
+    ):
         """Create an entry point, as expected to be provided by getExtraDlls."""
         return makeExeEntryPoint(
             logger=self,
             source_path=source_path,
             dest_path=dest_path,
+            module_name=module_name,
             package_name=package_name,
             reason=reason,
         )
@@ -904,6 +946,21 @@ Unwanted import of '%(unwanted)s' that %(problem)s '%(binding_name)s' encountere
         # Virtual method, pylint: disable=no-self-use
         return None
 
+    @classmethod
+    def getPluginDataFilesDir(cls):
+        """Helper function that returns path, where data files for the plugin are stored."""
+        plugin_filename = sys.modules[cls.__module__].__file__
+        return changeFilenameExtension(plugin_filename, "")
+
+    def getPluginDataFileContents(self, filename):
+        """Helper function that returns contents of a plugin data file."""
+        return getFileContents(
+            os.path.join(
+                self.getPluginDataFilesDir(),
+                filename,
+            )
+        )
+
     def getExtraCodeFiles(self):
         """Add extra code files to the compilation.
 
@@ -1035,6 +1092,10 @@ except ImportError:
         except NuitkaCalledProcessError as e:
             if e.returncode == 38:
                 return None
+
+            if Options.is_debug:
+                self.info(cmd)
+
             raise
 
         if str is not bytes:  # We want to work with strings, that's hopefully OK.
@@ -1090,6 +1151,11 @@ except ImportError:
         # Virtual method, pylint: disable=unused-argument
         return self.plugin_name
 
+    def getExtraConstantDefaultPopulation(self):
+        """Provide extra global constant values to code generation."""
+        # Virtual method, pylint: disable=no-self-use
+        return ()
+
     def decideAllowOutsideDependencies(self, module_name):
         """Decide if outside of Python dependencies are allowed.
 
@@ -1100,8 +1166,10 @@ except ImportError:
         return None
 
     @staticmethod
-    def getPackageVersion(distribution_name):
+    def getPackageVersion(module_name):
         """Provide package version of a distribution."""
+        distribution_name = _getDistributionNameFromPackageName(module_name)
+
         return _getPackageVersion(distribution_name)
 
     def getEvaluationConditionControlTags(self):
@@ -1125,6 +1193,9 @@ except ImportError:
                 "macos": isMacOS(),
                 "win32": isWin32Windows(),
                 "linux": isLinux(),
+                "android": isAndroidBasedLinux(),
+                "android32": isAndroidBasedLinux() and sys.maxsize < 2**32,
+                "android64": isAndroidBasedLinux() and sys.maxsize >= 2**64 - 1,
                 "anaconda": isAnacondaPython(),
                 "is_conda_package": isDistributionCondaPackage,
                 "debian_python": isDebianPackagePython(),
@@ -1133,6 +1204,7 @@ except ImportError:
                 "deployment": isDeploymentMode(),
                 # Querying package versions.
                 "version": _getPackageVersion,
+                "get_dist_name": _getDistributionNameFromPackageName,
                 "plugin": _isPluginActive,
                 "no_asserts": hasPythonFlagNoAsserts(),
                 "no_docstrings": hasPythonFlagNoDocStrings(),
@@ -1142,7 +1214,7 @@ except ImportError:
             }
         )
 
-        if isWin32Windows():
+        if isWin32Windows() or isMacOS():
             context.update(
                 {
                     "arch_x86": getArchitecture() == "x86",
@@ -1207,9 +1279,9 @@ except ImportError:
         plugins_logger.info(cls.plugin_name + ": " + message)
 
     @classmethod
-    def sysexit(cls, message, mnemonic=None):
+    def sysexit(cls, message, mnemonic=None, reporting=True):
         plugins_logger.sysexit(
-            cls.plugin_name + ": " + message, mnemonic=mnemonic, reporting=True
+            cls.plugin_name + ": " + message, mnemonic=mnemonic, reporting=reporting
         )
 
 

nuitka/plugins/Plugins.py

@@ -119,10 +119,8 @@ def _addActivePlugin(plugin_class, args, force=False):
     else:
         plugin_args = {}
 
-    try:
+    with withPluginProblemReporting(plugin_class, "Plugin initialization failed", ()):
         plugin_instance = plugin_class(**plugin_args)
-    except TypeError as e:
-        plugin_class.sysexit("Problem initializing plugin: %s" % e)
 
     assert isinstance(plugin_instance, NuitkaPluginBase), plugin_instance
 
@@ -465,8 +463,8 @@ class Plugins(object):
 
     @staticmethod
     def _reportImplicitImports(plugin, module, implicit_imports):
-        from nuitka.importing import Recursion
         from nuitka.importing.Importing import getModuleNameAndKindFromFilename
+        from nuitka.importing.Recursion import decideRecursion, recurseTo
 
         for full_name, module_filename in implicit_imports:
             # TODO: The module_kind should be forwarded from previous in the class using locateModule code.
@@ -475,7 +473,7 @@ class Plugins(object):
             )
 
             # This will get back to all other plugins allowing them to inhibit it though.
-            decision, decision_reason = Recursion.decideRecursion(
+            decision, decision_reason = decideRecursion(
                 using_module_name=module.getFullName(),
                 module_filename=module_filename,
                 module_name=full_name,
@@ -483,7 +481,7 @@ class Plugins(object):
             )
 
             if decision:
-                imported_module = Recursion.recurseTo(
+                imported_module = recurseTo(
                     module_name=full_name,
                     module_filename=module_filename,
                     module_kind=module_kind,
@@ -972,7 +970,7 @@ class Plugins(object):
                 fake_modules[full_name].append((fake_module, plugin, reason))
 
     @staticmethod
-    def onModuleSourceCode(module_name, source_code):
+    def onModuleSourceCode(module_name, source_filename, source_code):
         assert type(module_name) is ModuleName
         assert type(source_code) is str
 
@@ -980,7 +978,11 @@ class Plugins(object):
 
         for plugin in getActivePlugins():
             with withPluginModuleNameProblemReporting(plugin, module_name):
-                new_source_code = plugin.onModuleSourceCode(module_name, source_code)
+                new_source_code = plugin.onModuleSourceCode(
+                    module_name=module_name,
+                    source_filename=source_filename,
+                    source_code=source_code,
+                )
                 if new_source_code is not None and new_source_code != source_code:
                     source_code = new_source_code
                     contributing_plugins.add(plugin)
@@ -1039,6 +1041,43 @@ class Plugins(object):
 
         return result, deciding_plugins
 
+    module_usage_looked_ahead_cache = set()
+
+    @classmethod
+    def onModuleUsageLookAhead(cls, module_name, module_filename, module_kind):
+        if module_name in cls.module_usage_looked_ahead_cache:
+            return
+
+        cls.module_usage_looked_ahead_cache.add(module_name)
+
+        # Lazy load the source code if a plugin wants it, the pre_load caches
+        # the result for later usage.
+        def getModuleSourceCode():
+            if module_kind != "py":
+                return None
+
+            from nuitka.tree.SourceHandling import readSourceCodeFromFilename
+
+            if os.path.isdir(module_filename):
+                source_filename = os.path.join(module_filename, "__init__.py")
+            else:
+                source_filename = module_filename
+
+            if not os.path.isfile(source_filename):
+                return None
+
+            return readSourceCodeFromFilename(
+                module_name=module_name, source_filename=source_filename, pre_load=True
+            )
+
+        for plugin in getActivePlugins():
+            plugin.onModuleUsageLookAhead(
+                module_name=module_name,
+                module_filename=module_filename,
+                module_kind=module_kind,
+                get_module_source=getModuleSourceCode,
+            )
+
     @staticmethod
     def onModuleRecursion(
         module_name, module_filename, module_kind, using_module_name, source_ref, reason
@@ -1303,9 +1342,9 @@ class Plugins(object):
 
     @classmethod
     def encodeDataComposerName(cls, name):
+        # Encoding needs to match generated source code output.
         if str is not bytes:
-            # Encoding needs to match generated source code output.
-            name = name.encode("latin1")
+            name = name.encode("utf8")
 
         for plugin in getActivePlugins():
             r = plugin.encodeDataComposerName(name)
@@ -1336,42 +1375,46 @@ class Plugins(object):
                 yield value
 
     @classmethod
-    def decideAllowOutsideDependencies(cls, module_name):
-        if not Options.isExperimental("no-outside-dependencies"):
-            return None
+    def getExtraConstantDefaultPopulation(cls):
+        for plugin in getActivePlugins():
+            for value in plugin.getExtraConstantDefaultPopulation():
+                yield value
 
+    @classmethod
+    def decideAllowOutsideDependencies(cls, module_name):
         result = None
         plugin_name = None
 
-        if module_name is not None:
-            for plugin in getActivePlugins():
-                value = plugin.decideAllowOutsideDependencies(module_name)
+        assert module_name is not None
 
-                if value is True:
-                    if result is False:
-                        plugin.sysexit(
-                            "Error, conflicting allow/disallow outside dependencies of plug-in '%s'."
-                            % plugin_name
-                        )
+        for plugin in getActivePlugins():
+            value = plugin.decideAllowOutsideDependencies(module_name)
 
-                    result = True
-                    plugin_name = plugin.plugin_name
+            if value is True:
+                if result is False:
+                    plugin.sysexit(
+                        "Error, conflicting allow/disallow outside dependencies of plug-in '%s'."
+                        % plugin_name
+                    )
 
-                elif value is False:
-                    if result is False:
-                        plugin.sysexit(
-                            "Error, conflicting allow/disallow outside dependencies of plug-in '%s'."
-                            % plugin_name
-                        )
+                result = True
+                plugin_name = plugin.plugin_name
 
-                    result = False
-                    plugin_name = plugin.plugin_name
-                elif value is not None:
+            elif value is False:
+                if result is False:
                     plugin.sysexit(
-                        "Error, can only return True, False, None from 'decideAllowOutsideDependencies' not %r"
-                        % value
+                        "Error, conflicting allow/disallow outside dependencies of plug-in '%s'."
+                        % plugin_name
                     )
 
+                result = False
+                plugin_name = plugin.plugin_name
+            elif value is not None:
+                plugin.sysexit(
+                    "Error, can only return True, False, None from 'decideAllowOutsideDependencies' not %r"
+                    % value
+                )
+
         return result
 
     @classmethod

nuitka/plugins/standard/AntiBloatPlugin.py

@@ -92,6 +92,10 @@ class NuitkaPluginAntiBloat(NuitkaPluginBase):
                 noinclude_setuptools_mode,
                 "setuptools",
             )
+            self.handled_modules["triton"] = (
+                noinclude_setuptools_mode,
+                "setuptools",
+            )
         else:
             self.control_tags["use_setuptools"] = True
 
@@ -138,6 +142,10 @@ class NuitkaPluginAntiBloat(NuitkaPluginBase):
                 noinclude_ipython_mode,
                 "IPython",
             )
+            self.handled_modules["altair._magics"] = (
+                noinclude_ipython_mode,
+                "IPython",
+            )
         else:
             self.control_tags["use_ipython"] = True
 
@@ -446,7 +454,7 @@ Error, cannot evaluate module '%s' append code '%s' in '%s' due to: %s"""
 
         return source_code
 
-    def onModuleSourceCode(self, module_name, source_code):
+    def onModuleSourceCode(self, module_name, source_filename, source_code):
         for anti_bloat_config in self.config.get(module_name, section="anti-bloat"):
             if self.evaluateCondition(
                 full_name=module_name, condition=anti_bloat_config.get("when", "True")
@@ -533,6 +541,34 @@ Error, cannot eval module '%s' function '%s' replacement code '%s' in '%s' due t
 
         return result
 
+    def _getModuleBloatModeOverrides(self, using_module_name, intended_module_name):
+        while 1:
+            config = self.config.get(using_module_name, section="anti-bloat")
+
+            if config:
+                for anti_bloat_config in config:
+                    bloat_mode_overrides = anti_bloat_config.get(
+                        "bloat-mode-overrides", ()
+                    )
+
+                    if not bloat_mode_overrides:
+                        continue
+
+                    if self.evaluateCondition(
+                        full_name=intended_module_name,
+                        condition=anti_bloat_config.get("when", "True"),
+                    ):
+                        for module_name, mode in bloat_mode_overrides.items():
+                            if module_name == intended_module_name:
+                                return mode
+
+            using_module_name = using_module_name.getPackageName()
+
+            if not using_module_name:
+                break
+
+        return None
+
     def onModuleRecursion(
         self,
         module_name,
@@ -567,6 +603,15 @@ Error, cannot eval module '%s' function '%s' replacement code '%s' in '%s' due t
                 return
 
             if module_name.hasNamespace(handled_module_name):
+                if using_module_name is not None:
+                    override_mode = self._getModuleBloatModeOverrides(
+                        using_module_name=using_module_name,
+                        intended_module_name=intended_module_name,
+                    )
+
+                    if override_mode is not None:
+                        mode = override_mode
+
                 # Make sure the compilation aborts or warns if asked to
                 if mode == "error":
                     raise NuitkaForbiddenImportEncounter(

nuitka/plugins/standard/ConsiderPyLintAnnotationsPlugin.py

@@ -83,7 +83,7 @@ if False:
     class NuitkaPluginDetectorPylintEclipseAnnotations(NuitkaPluginBase):
         detector_for = NuitkaPluginPylintEclipseAnnotations
 
-        def onModuleSourceCode(self, module_name, source_code):
+        def onModuleSourceCode(self, module_name, source_filename, source_code):
             if re.search(r"#\s*pylint:\s*disable=\s*(\w+)", source_code):
                 self.warnUnusedPlugin(
                     "Understand PyLint/PyDev annotations for warnings."

nuitka/plugins/standard/DelvewheelPlugin.py

@@ -63,7 +63,7 @@ class NuitkaPluginDelvewheel(NuitkaPluginBase):
     def _add_dll_directory(self, arg):
         self.dll_directory = arg
 
-    def onModuleSourceCode(self, module_name, source_code):
+    def onModuleSourceCode(self, module_name, source_filename, source_code):
         # Avoid regular expression match if possible.
         if "_delvewheel_" not in source_code:
             return None
@@ -136,6 +136,7 @@ class NuitkaPluginDelvewheel(NuitkaPluginBase):
                     dest_path=os.path.join(
                         os.path.basename(dll_directory), dll_basename
                     ),
+                    module_name=full_name,
                     package_name=full_name,
                     reason="needed by '%s'" % full_name.asString(),
                 )

nuitka/plugins/standard/DillPlugin.py

@@ -33,110 +33,14 @@ class NuitkaPluginDillWorkarounds(NuitkaPluginBase):
     def isAlwaysEnabled():
         return False
 
-    @staticmethod
-    def createPostModuleLoadCode(module):
+    def createPostModuleLoadCode(self, module):
         full_name = module.getFullName()
 
         if full_name == "dill":
-            code = r"""\
-import dill._dill
-
-# Compiled methods need to be created.
-@dill.register(compiled_method)
-def save_compiled_method(pickler, obj):
-    if str is not bytes:
-        pickler.save_reduce(compiled_method, (obj.__func__, obj.__self__), obj=obj)
-    else:
-        pickler.save_reduce(compiled_method, (obj.im_func, obj.im_self, obj.im_class), obj=obj)
-
-def _create_compiled_function2(module_name, func_values, func_dict, func_defaults):
-    if module_name not in compiled_function_tables:
-        __import__(module_name)
-
-    func = compiled_function_tables[module_name][1](*func_values)
-    if func_dict:
-        for key, value in func_dict.items():
-            func[key] = value
-
-    func.__defaults__ = func_defaults
-
-    return func
-
-def _create_compiled_function3(module_name, func_values, func_dict, func_defaults, func_kwdefaults):
-    if module_name not in compiled_function_tables:
-        __import__(module_name)
-
-    func = compiled_function_tables[module_name][1](*func_values)
-    if func_dict:
-        for key, value in func_dict.items():
-            func[key] = value
-
-    func.__defaults__ = func_defaults
-    func.__kwdefaults__ = func_kwdefaults
-
-    return func
-
-
-# Compiled methods might have to be created or not.
-@dill.register(compiled_function)
-def save_compiled_function(pickler, obj):
-    if not dill._dill._locate_function(obj):
-        stack = dill._dill.stack
-
-        if getattr(pickler, '_recurse', False):
-            from dill.detect import globalvars
-            globs = globalvars(obj, recurse=True, builtin=True)
-            if id(obj) in stack:
-                globs = obj.__globals__ if str is not bytes else obj.func_globals
-        else:
-            globs = obj.__globals__ if str is not bytes else obj.func_globals
-
-        _byref = getattr(pickler, '_byref', None)
-        _recurse = getattr(pickler, '_recurse', None)
-        _memo = (id(obj) in stack) and (_recurse is not None)
-        stack[id(obj)] = len(stack), obj
-
-        if str is not bytes:
-            # Python3
-            _super = ('super' in getattr(obj.__code__,'co_names',())) and (_byref is not None)
-            if _super: pickler._byref = True
-            if _memo: pickler._recurse = False
-
-            pickler.save_reduce(
-                _create_compiled_function3,
-                (
-                    obj.__module__,
-                    compiled_function_tables[obj.__module__][0](obj),
-                    obj.__dict__,
-                    obj.__defaults__,
-                    obj.__kwdefaults__
-                )
-            )
-        else:
-            # Python2
-            _super = ('super' in getattr(obj.__code__,'co_names',())) and (_byref is not None) and getattr(pickler, '_recurse', False)
-            if _super: pickler._byref = True
-            if _memo: pickler._recurse = False
-
-            pickler.save_reduce(
-                _create_compiled_function2,
-                (
-                    obj.__module__,
-                    compiled_function_tables[obj.__module__][0](obj),
-                    obj.__dict__,
-                    obj.__defaults__
-                )
-            )
-
-        if _super: pickler._byref = _byref
-        if _memo: pickler._recurse = _recurse
-    else:
-        dill._dill.StockPickler.save_global(pickler, obj)
-"""
             return (
-                code,
+                self.getPluginDataFileContents("dill-postLoad.py"),
                 """\
-Extending "dill" for compiled types to be pickable as well.""",
+Extending "dill" for compiled types to be pickle-able as well.""",
             )
 
     @staticmethod