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

{Nuitka_winsvc-1.8.6.dist-info → Nuitka_winsvc-1.9.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64
 

nuitka/BytecodeCaching.py

@@ -107,7 +107,10 @@ def getCachedImportedModuleUsageAttempts(module_name, source_code, source_ref):
             finding != module_used["finding"]
             or module_kind != module_used["module_kind"]
         ):
-            assert module_name != "email._header_value_parser", finding
+            assert module_name != "email._header_value_parser", (
+                finding,
+                module_used["finding"],
+            )
 
             return None
 

nuitka/HardImportRegistry.py

@@ -0,0 +1,348 @@
+#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
+#
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+#
+""" Registry for hard import data.
+
+Part of it is static, but modules can get at during scan by plugins that
+know how to handle these.
+"""
+
+import os
+import sys
+
+from nuitka.nodes.ConstantRefNodes import ExpressionConstantSysVersionInfoRef
+from nuitka.PythonVersions import (
+    getFutureModuleKeys,
+    getImportlibSubPackages,
+    python_version,
+)
+from nuitka.utils.Utils import isWin32Windows
+
+# These module are supported in code generation to be imported the hard way.
+hard_modules = set(
+    (
+        "os",
+        "ntpath",
+        "posixpath",
+        # TODO: Add mac path package too
+        "sys",
+        "types",
+        "typing",
+        "__future__",
+        "importlib",
+        "importlib.resources",
+        "importlib.metadata",
+        "_frozen_importlib",
+        "_frozen_importlib_external",
+        "pkgutil",
+        "functools",
+        "sysconfig",
+        "unittest",
+        "unittest.mock",
+        # "cStringIO",
+        "io",
+        "_io",
+        "ctypes",
+        "ctypes.wintypes",
+        "ctypes.macholib",
+        # TODO: Once generation of nodes for functions exists.
+        # "platform",
+        "builtins",
+    )
+)
+
+hard_modules_aliases = {
+    "os.path": os.path.__name__,
+}
+
+# Lets put here, hard modules that are kind of backports only.
+hard_modules_stdlib = hard_modules
+hard_modules_non_stdlib = set(
+    (
+        "site",
+        "pkg_resources",
+        "importlib_metadata",
+        "importlib_resources",
+    )
+)
+
+hard_modules = hard_modules | hard_modules_non_stdlib
+
+hard_modules_version = {
+    "cStringIO": (None, 0x300, None),
+    "typing": (0x350, None, None),
+    "_frozen_importlib": (0x300, None, None),
+    "_frozen_importlib_external": (0x350, None, None),
+    "importlib.resources": (0x370, None, None),
+    "importlib.metadata": (0x380, None, None),
+    "ctypes.wintypes": (None, None, "win32"),
+    "builtin": (0x300, None, None),
+}
+
+hard_modules_limited = ("importlib.metadata", "ctypes.wintypes", "importlib_metadata")
+
+
+# The modules were added during compile time, no helper code available.
+hard_modules_dynamic = set()
+
+
+def isHardModule(module_name):
+    if module_name not in hard_modules:
+        return False
+
+    min_version, max_version, os_limit = hard_modules_version.get(
+        module_name, (None, None, None)
+    )
+
+    if min_version is not None and python_version < min_version:
+        return False
+
+    if max_version is not None and python_version >= max_version:
+        return False
+
+    if os_limit is not None:
+        if os_limit == "win32":
+            return isWin32Windows()
+
+    return True
+
+
+# These modules can cause issues if imported during compile time.
+hard_modules_trust_with_side_effects = set(["site"])
+if not isWin32Windows():
+    # Crashing on anything but Windows.
+    hard_modules_trust_with_side_effects.add("ctypes.wintypes")
+
+
+def isHardModuleWithoutSideEffect(module_name):
+    return (
+        module_name in hard_modules
+        and module_name not in hard_modules_trust_with_side_effects
+    )
+
+
+trust_undefined = 0
+trust_constant = 1
+trust_exist = 2
+trust_module = trust_exist
+trust_future = trust_exist
+trust_importable = 3
+trust_node = 4
+trust_may_exist = 5
+trust_not_exist = 6
+trust_node_factory = {}
+
+module_importlib_trust = dict(
+    (key, trust_importable) for key in getImportlibSubPackages()
+)
+
+if "metadata" not in module_importlib_trust:
+    module_importlib_trust["metadata"] = trust_undefined
+if "resources" not in module_importlib_trust:
+    module_importlib_trust["resources"] = trust_undefined
+
+module_sys_trust = {
+    "version": trust_constant,
+    "hexversion": trust_constant,  # spell-checker: ignore hexversion
+    "platform": trust_constant,
+    "maxsize": trust_constant,
+    "byteorder": trust_constant,
+    "builtin_module_names": trust_constant,
+    "stdout": trust_exist,
+    "stderr": trust_exist,
+}
+
+if python_version < 0x270:
+    module_sys_trust["version_info"] = trust_constant
+else:
+    module_sys_trust["version_info"] = trust_node
+    trust_node_factory[("sys", "version_info")] = ExpressionConstantSysVersionInfoRef
+
+module_builtins_trust = {}
+if python_version >= 0x300:
+    module_builtins_trust["open"] = trust_node
+
+if python_version < 0x300:
+    module_sys_trust["exc_type"] = trust_may_exist
+    module_sys_trust["exc_value"] = trust_may_exist
+    module_sys_trust["exc_traceback"] = trust_may_exist
+
+    module_sys_trust["maxint"] = trust_constant
+    module_sys_trust["subversion"] = trust_constant
+else:
+    module_sys_trust["exc_type"] = trust_not_exist
+    module_sys_trust["exc_value"] = trust_not_exist
+    module_sys_trust["exc_traceback"] = trust_not_exist
+
+module_typing_trust = {
+    "TYPE_CHECKING": trust_constant,
+}
+
+module_os_trust = {
+    "name": trust_constant,
+    "listdir": trust_node,
+    "curdir": trust_constant,
+    "pardir": trust_constant,
+    "sep": trust_constant,
+    "extsep": trust_constant,
+    "altsep": trust_constant,
+    "pathsep": trust_constant,
+    "linesep": trust_constant,
+}
+
+module_os_path_trust = {
+    "exists": trust_node,
+    "isfile": trust_node,
+    "isdir": trust_node,
+    "basename": trust_node,
+}
+
+
+module_ctypes_trust = {
+    "CDLL": trust_node,
+}
+
+# module_platform_trust = {"python_implementation": trust_function}
+
+hard_modules_trust = {
+    "os": module_os_trust,
+    "ntpath": module_os_path_trust if os.path.__name__ == "ntpath" else {},
+    "posixpath": module_os_path_trust if os.path.__name__ == "posixpath" else {},
+    "sys": module_sys_trust,
+    #     "platform": module_platform_trust,
+    "types": {},
+    "typing": module_typing_trust,
+    "__future__": dict((key, trust_future) for key in getFutureModuleKeys()),
+    "importlib": module_importlib_trust,
+    "importlib.metadata": {
+        "version": trust_node,
+        "distribution": trust_node,
+        "metadata": trust_node,
+        "entry_points": trust_node,
+        "PackageNotFoundError": trust_exist,
+    },
+    "importlib_metadata": {
+        "version": trust_node,
+        "distribution": trust_node,
+        "metadata": trust_node,
+        "entry_points": trust_node,
+        "PackageNotFoundError": trust_exist,
+    },
+    "_frozen_importlib": {},
+    "_frozen_importlib_external": {},
+    "pkgutil": {"get_data": trust_node},
+    "functools": {"partial": trust_exist},
+    "sysconfig": {},
+    "unittest": {"mock": trust_module, "main": trust_exist},
+    "unittest.mock": {},
+    "io": {"BytesIO": trust_exist, "StringIO": trust_exist},
+    "_io": {"BytesIO": trust_exist, "StringIO": trust_exist},
+    # "cStringIO": {"StringIO": trust_exist},
+    "pkg_resources": {
+        "require": trust_node,
+        "get_distribution": trust_node,
+        "iter_entry_points": trust_node,
+        "resource_string": trust_node,
+        "resource_stream": trust_node,
+    },
+    "importlib.resources": {
+        "read_binary": trust_node,
+        "read_text": trust_node,
+        "files": trust_node,
+    },
+    "importlib_resources": {
+        "read_binary": trust_node,
+        "read_text": trust_node,
+        "files": trust_node,
+    },
+    "ctypes": module_ctypes_trust,
+    "site": {},
+    "ctypes.wintypes": {},
+    "ctypes.macholib": {},
+    "builtins": module_builtins_trust,
+}
+
+
+def _addHardImportNodeClasses():
+    from nuitka.nodes.HardImportNodesGenerated import hard_import_node_classes
+
+    for hard_import_node_class, spec in hard_import_node_classes.items():
+        module_name, function_name = spec.name.rsplit(".", 1)
+
+        if module_name in hard_modules_aliases:
+            module_name = hard_modules_aliases.get(module_name)
+
+        trust_node_factory[(module_name, function_name)] = hard_import_node_class
+
+        # hard_modules_trust[module_name][function_name] = trust_node
+
+
+_addHardImportNodeClasses()
+
+# Remove this one again, not available on Windows, but the node generation does
+# not know that.
+if isWin32Windows():
+    module_os_trust["uname"] = trust_not_exist
+
+
+def _checkHardModules():
+    for module_name in hard_modules:
+        assert module_name in hard_modules_trust, module_name
+
+    for module_name, trust in hard_modules_trust.items():
+        assert module_name in hard_modules, module_name
+
+        for attribute_name, trust_value in trust.items():
+            if trust_value is trust_node:
+                assert (
+                    module_name,
+                    attribute_name,
+                ) in trust_node_factory or os.path.basename(sys.argv[0]).startswith(
+                    "generate-"
+                ), (
+                    module_name,
+                    attribute_name,
+                )
+
+
+_checkHardModules()
+
+
+def addModuleTrust(module_name, attribute_name, trust_value):
+    hard_modules_trust[module_name][attribute_name] = trust_value
+
+
+def addModuleSingleAttributeNodeFactory(module_name, attribute_name, node_class):
+    hard_modules_trust[module_name][attribute_name] = trust_node
+    trust_node_factory[(module_name, attribute_name)] = node_class
+
+
+def addModuleAttributeFactory(module_name, attribute_name, node_class):
+    trust_node_factory[(module_name, attribute_name)] = node_class
+
+
+def addModuleDynamicHard(module_name):
+    hard_modules.add(module_name)
+    hard_modules_dynamic.add(module_name)
+    hard_modules_non_stdlib.add(module_name)
+
+    if module_name not in hard_modules_trust:
+        hard_modules_trust[module_name] = {}
+
+
+def isHardModuleDynamic(module_name):
+    return module_name in hard_modules_dynamic

nuitka/MainControl.py

@@ -29,7 +29,10 @@ import sys
 
 from nuitka.build.DataComposerInterface import runDataComposer
 from nuitka.build.SconsUtils import getSconsReportValue, readSconsReport
-from nuitka.code_generation.ConstantCodes import addDistributionMetadataValue
+from nuitka.code_generation.ConstantCodes import (
+    addDistributionMetadataValue,
+    getDistributionMetadataValues,
+)
 from nuitka.freezer.IncludedDataFiles import (
     addIncludedDataFilesFromFileOptions,
     addIncludedDataFilesFromPackageOptions,
@@ -51,6 +54,7 @@ from nuitka.Options import (
     hasPythonFlagNoDocStrings,
     hasPythonFlagNoWarnings,
     hasPythonFlagUnbuffered,
+    isExperimental,
 )
 from nuitka.plugins.Plugins import Plugins
 from nuitka.PostProcessing import executePostProcessing
@@ -67,6 +71,7 @@ from nuitka.PythonFlavors import (
     isPyenvPython,
 )
 from nuitka.PythonVersions import (
+    getModuleLinkerLibs,
     getPythonABI,
     getSupportedPythonVersions,
     python_version,
@@ -103,7 +108,6 @@ from . import ModuleRegistry, Options, OutputDirectories
 from .build.SconsInterface import (
     asBoolStr,
     cleanSconsDirectory,
-    getSconsDataPath,
     runScons,
     setCommonSconsOptions,
 )
@@ -123,16 +127,6 @@ from .tree.SourceHandling import writeSourceCode
 from .TreeXML import dumpTreeXMLToFile
 
 
-def _setupFromMainFilenames():
-    main_filenames = Options.getMainEntryPointFilenames()
-    for filename in main_filenames:
-        # Inform the importing layer about the main script directory, so it can use
-        # it when attempting to follow imports.
-        Importing.addMainScriptDirectory(
-            main_dir=os.path.dirname(os.path.abspath(filename))
-        )
-
-
 def _createMainModule():
     """Create a node tree.
 
@@ -142,7 +136,7 @@ def _createMainModule():
     directory paths.
 
     """
-    # Many cases to deal with, pylint: disable=too-many-branches
+    # Many cases and details to deal with, pylint: disable=too-many-branches,too-many-locals
 
     Plugins.onBeforeCodeParsing()
 
@@ -246,7 +240,9 @@ def _createMainModule():
             )
 
         Recursion.checkPluginSinglePath(
-            plugin_filename=module_filename, module_package=module_name.getPackageName()
+            plugin_filename=module_filename,
+            module_package=module_name.getPackageName(),
+            package_only=True,
         )
 
     # Allow plugins to add more modules based on the initial set being complete.
@@ -262,6 +258,18 @@ def _createMainModule():
     if Options.isStandaloneMode():
         checkFreezingModuleSet()
 
+    # Check if distribution meta data is included, that cannot be used.
+    for distribution_name, (
+        package_name,
+        _metadata,
+        _entry_points,
+    ) in getDistributionMetadataValues():
+        if not ModuleRegistry.hasDoneModule(package_name):
+            inclusion_logger.sysexit(
+                "Error, including metadata for distribution '%s' without including related package '%s'."
+                % (distribution_name, package_name)
+            )
+
     # Allow plugins to comment on final module set.
     Plugins.onModuleCompleteSet()
 
@@ -578,8 +586,6 @@ def runSconsBackend():
         "full_compat": asBoolStr(Options.is_full_compat),
         "experimental": ",".join(Options.getExperimentalIndications()),
         "trace_mode": asBoolStr(Options.shallTraceExecution()),
-        "python_version": python_version_str,
-        "nuitka_src": getSconsDataPath(),
         "file_reference_mode": Options.getFileReferenceMode(),
         "module_count": "%d" % len(ModuleRegistry.getDoneModules()),
     }
@@ -693,6 +699,10 @@ def runSconsBackend():
     if Options.shallMakeModule():
         options["module_suffix"] = getSharedLibrarySuffix(preferred=True)
 
+    link_module_libs = getModuleLinkerLibs()
+    if link_module_libs:
+        options["link_module_libs"] = ",".join(link_module_libs)
+
     env_values = setCommonSconsOptions(options)
 
     # Allow plugins to build definitions.
@@ -878,9 +888,9 @@ def compileTree():
     general.info("Running C compilation via Scons.")
 
     # Run the Scons to build things.
-    result, options = runSconsBackend()
+    result, scons_options = runSconsBackend()
 
-    return result, options
+    return result, scons_options
 
 
 def handleSyntaxError(e):
@@ -943,7 +953,9 @@ def _main():
         else None,
     )
 
-    _setupFromMainFilenames()
+    # Initialize the importing layer from options, main filenames, debugging
+    # options, etc.
+    Importing.setupImportingFromOptions()
 
     addIncludedDataFilesFromFileOptions()
     addIncludedDataFilesFromPackageOptions()
@@ -959,7 +971,7 @@ def _main():
     dumpTreeXML()
 
     # Make the actual compilation.
-    result, options = compileTree()
+    result, scons_options = compileTree()
 
     # Exit if compilation failed.
     if not result:
@@ -986,7 +998,7 @@ def _main():
     copyDataFiles()
 
     if Options.isStandaloneMode():
-        binary_filename = options["result_exe"]
+        binary_filename = scons_options["result_exe"]
 
         setMainEntryPoint(binary_filename)
 
@@ -1040,14 +1052,14 @@ def _main():
     if Options.isStandaloneMode() and isMacOS():
         general.info(
             "Created binary that runs on macOS %s (%s) or higher."
-            % (options["macos_min_version"], options["macos_target_arch"])
+            % (scons_options["macos_min_version"], scons_options["macos_target_arch"])
         )
 
-        if options["macos_target_arch"] != getArchitecture():
+        if scons_options["macos_target_arch"] != getArchitecture():
             general.warning(
                 "It will only work as well as 'arch -%s %s %s' does."
                 % (
-                    options["macos_target_arch"],
+                    scons_options["macos_target_arch"],
                     sys.executable,
                     Options.getMainEntryPointFilenames()[0],
                 ),
@@ -1106,6 +1118,14 @@ def main():
         try:
             writeCompilationReports(aborted=True)
         except BaseException as e:  # Catch all the things, pylint: disable=broad-except
-            general.warning("Report writing was prevented by exception %s" % e)
+            general.warning(
+                """\
+Report writing was prevented by exception %r, use option \
+'--experimental=debug-report-traceback' for full traceback."""
+                % e
+            )
+
+            if isExperimental("debug-report-traceback"):
+                raise
 
         raise

nuitka/OptionParsing.py

@@ -358,6 +358,16 @@ When creating the onefile, disable compression of the payload. This is
 mostly for debug purposes, or to save time. Default is off.""",
 )
 
+onefile_group.add_option(
+    "--onefile-as-archive",
+    action="store_true",
+    dest="onefile_as_archive",
+    default=False,
+    help="""\
+When creating the onefile, use an archive format, that can be unpacked
+with "nuitka-onefile-unpack" rather than a stream that only the onefile
+program itself unpacks. Default is off.""",
+)
 
 del onefile_group
 
@@ -423,8 +433,8 @@ data_group.add_option(
     help="""\
 Do not include data files matching the filename pattern given. This is against
 the target filename, not source paths. So to ignore a file pattern from package
-data for "package_name" should be matched as "package_name/*.txt". Or for the
-whole directory simply use "package_name". Default empty.""",
+data for 'package_name' should be matched as 'package_name/*.txt'. Or for the
+whole directory simply use 'package_name'. Default empty.""",
 )
 
 data_group.add_option(
@@ -468,8 +478,8 @@ dll_group.add_option(
     default=[],
     help="""\
 Do not include DLL files matching the filename pattern given. This is against
-the target filename, not source paths. So ignore a DLL "someDLL" contained in
-the package "package_name" it should be matched as "package_name/someDLL.*".
+the target filename, not source paths. So ignore a DLL 'someDLL' contained in
+the package 'package_name' it should be matched as 'package_name/someDLL.*'.
 Default empty.""",
 )
 
@@ -687,7 +697,7 @@ output_group.add_option(
     dest="pyi_file",
     default=True,
     help="""\
-Do not create a ".pyi" file for extension modules created by Nuitka. This is
+Do not create a '.pyi' file for extension modules created by Nuitka. This is
 used to detect implicit imports.
 Defaults to off.""",
 )
@@ -947,7 +957,7 @@ del c_compiler_group
 
 caching_group = parser.add_option_group("Cache Control")
 
-_cache_names = ("all", "ccache", "bytecode")
+_cache_names = ("all", "ccache", "bytecode", "compression")
 
 if isWin32Windows():
     _cache_names += ("dll-dependencies",)
@@ -1136,7 +1146,7 @@ tracing_group.add_option(
     metavar="REPORT_DESC",
     default=[],
     help="""\
-Report via template. Provide template and output filename "template.rst.j2:output.rst". For
+Report via template. Provide template and output filename 'template.rst.j2:output.rst'. For
 built-in templates, check the User Manual for what these are. Can be given multiple times.
 Default is empty.""",
 )
@@ -1955,8 +1965,7 @@ def _considerGithubWorkflowOptions(phase):
 
 def parseOptions(logger):
     # Pretty complex code, having a small options parser and many details as
-    # well as integrating with plugins and run modes, and dispatching of tool
-    # mode executions, pylint: disable=too-many-branches,too-many-statements
+    # well as integrating with plugins and run modes. pylint: disable=too-many-branches
 
     # First, isolate the first non-option arguments.
     extra_args = []
@@ -2027,6 +2036,19 @@ def parseOptions(logger):
 Error, need filename argument with python module or main program."""
         )
 
+    if not options.immediate_execution and len(positional_args) > 1:
+        parser.print_help()
+
+        logger.sysexit(
+            """
+Error, specify only one positional argument unless "--run" is specified to
+pass them to the compiled program execution."""
+        )
+
+    return is_nuitka_run, options, positional_args, extra_args
+
+
+def runSpecialCommandsFromOptions(options):
     if options.plugin_list:
         from nuitka.plugins.Plugins import listPlugins
 
@@ -2065,14 +2087,3 @@ Error, need filename argument with python module or main program."""
             report_filename=os.path.expanduser(options.compilation_report_filename),
         )
         sys.exit(0)
-
-    if not options.immediate_execution and len(positional_args) > 1:
-        parser.print_help()
-
-        logger.sysexit(
-            """
-Error, specify only one positional argument unless "--run" is specified to
-pass them to the compiled program execution."""
-        )
-
-    return is_nuitka_run, options, positional_args, extra_args