Nuitka-winsvc 2.4.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/plugins/standard/stdlib3.nuitka-package.config.yml

@@ -252,6 +252,30 @@
       change_function:
         '_main': "'(lambda: None)'"
 
+- module-name: 'multiprocessing' # checksum: 96475306
+  anti-bloat:
+    - description: "workaround for 'sys.frozen' not being set"
+      replacements_plain:
+        "getattr(sys, 'frozen', False)": 'True'
+
+- module-name: 'multiprocessing.context' # checksum: 96475306
+  anti-bloat:
+    - description: "workaround for 'sys.frozen' not being set"
+      replacements_plain:
+        "getattr(sys, 'frozen', False)": 'True'
+
+- module-name: 'multiprocessing.forking' # checksum: 96475306
+  anti-bloat:
+    - description: "workaround for 'sys.frozen' not being set"
+      replacements_plain:
+        "getattr(sys, 'frozen', False)": 'True'
+
+- module-name: 'multiprocessing.popen_spawn_win32' # checksum: 96475306
+  anti-bloat:
+    - description: "workaround for 'sys.frozen' not being set"
+      replacements_plain:
+        "getattr(sys, 'frozen', False)": 'True'
+
 - module-name: 'multiprocessing.resource_tracker' # checksum: e8bba98a
   anti-bloat:
     - description: "workaround for starting 'multiprocessing resource tracker"
@@ -259,6 +283,12 @@
         "args += ['-c', cmd % r]": "args += ['--multiprocessing-resource-tracker', str(r)]"
       when: 'not module_mode'
 
+- module-name: 'multiprocessing.spawn' # checksum: 96475306
+  anti-bloat:
+    - description: "workaround for 'sys.frozen' not being set"
+      replacements_plain:
+        "getattr(sys, 'frozen', False)": 'True'
+
 - module-name: 'opcode' # checksum: bef1771d
   implicit-imports:
     # Overcome default non-inclusion of this module, required now
@@ -410,10 +440,13 @@
     - depends:
         - 'xml.sax.expatreader'
 
-- module-name: 'xmlrpc.server' # checksum: 105ff40e
+- module-name: 'xmlrpc.server' # checksum: 57da2566
   anti-bloat:
-    - replacements_plain:
+    - description: 'avoid using pydoc'
+      replacements_plain:
         'import pydoc': ''
+      change_class:
+        'ServerHTMLDoc': 'un-usable'
       when: 'not use_pydoc'
 
 - module-name: 'zipapp' # checksum: 6a44b57d

nuitka/reports/CompilationReportReader.py

@@ -51,6 +51,18 @@ def getCompilationOutputBinary(compilation_report, prefixes):
     )
 
 
+def getEmbeddedDataFilenames(compilation_report):
+    result = []
+
+    for datafile_node in compilation_report.findall("data_file"):
+        if "embed-run-time" in datafile_node.attrib["tags"].split(
+            ","
+        ) or "embed-compile-time" in datafile_node.attrib["tags"].split(","):
+            result.append(datafile_node.attrib["name"])
+
+    return result
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/reports/Reports.py

@@ -20,6 +20,7 @@ from nuitka.code_generation.ConstantCodes import getDistributionMetadataValues
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.freezer.IncludedDataFiles import getIncludedDataFiles
 from nuitka.freezer.IncludedEntryPoints import getStandaloneEntryPoints
+from nuitka.freezer.Standalone import getRemovedUsedDllsInfo
 from nuitka.importing.Importing import getPackageSearchPath
 from nuitka.importing.Recursion import getRecursionDecisions
 from nuitka.ModuleRegistry import (
@@ -640,6 +641,16 @@ def writeCompilationReport(report_filename, report_input_data, diffable):
             # TODO: No reason yet.
         )
 
+    for standalone_entry_point, (reason, removed_dll_paths) in getRemovedUsedDllsInfo():
+        for removed_dll_path in removed_dll_paths:
+            TreeXML.appendTreeElement(
+                root,
+                "excluded_dll",
+                name=_getCompilationReportPath(removed_dll_path),
+                used_by=standalone_entry_point.dest_path,
+                reason=reason,
+            )
+
     if not diffable:
         data_composer_values = getDataComposerReportValues()
 

nuitka/specs/BuiltinParameterSpecs.py

@@ -240,6 +240,10 @@ def makeBuiltinExceptionParameterSpec(exception_name):
         return BuiltinParameterSpecExceptionsKwOnly(
             exception_name=exception_name, kw_only_args=("name", "path")
         )
+    elif exception_name == "AttributeError" and python_version >= 0x3A0:
+        return BuiltinParameterSpecExceptionsKwOnly(
+            exception_name=exception_name, kw_only_args=("name", "obj")
+        )
     else:
         return BuiltinParameterSpecExceptions(exception_name=exception_name)
 
@@ -461,7 +465,7 @@ builtin_issubclass_spec = BuiltinParameterSpecNoKeywords(
 
 class BuiltinBytearraySpec(BuiltinParameterSpecPosArgs):
     def isCompileTimeComputable(self, values):
-        # For bytearrays, we need to avoid the case of large bytearray
+        # For bytearray objects, we need to avoid the case of large bytearray
         # construction from an integer at compile time.
 
         result = BuiltinParameterSpec.isCompileTimeComputable(self, values=values)

nuitka/specs/HardImportSpecs.py

@@ -143,6 +143,13 @@ os_path_isabs_spec = BuiltinParameterSpec(
 
 os_listdir_spec = BuiltinParameterSpec("os.listdir", ("path",), default_count=1)
 
+os_stat_spec = BuiltinParameterSpec(
+    "os.stat", ("path",), kw_only_args=("dir_fd", "follow_symlinks"), default_count=2
+)
+os_lstat_spec = BuiltinParameterSpec(
+    "os.lstat", ("path",), kw_only_args=("dir_fd",), default_count=1
+)
+
 ctypes_cdll_since_38_spec = BuiltinParameterSpec(
     "ctypes.CDLL",
     (

nuitka/specs/ParameterSpecs.py

@@ -350,9 +350,9 @@ def matchCall(
             assigned_tuple_params.append(arg)
             value = iter(value.getIterationValues())
 
-            for i, subarg in enumerate(arg):
+            for i, sub_arg in enumerate(arg):
                 try:
-                    subvalue = next(value)
+                    sub_value = next(value)
                 except StopIteration:
                     raise TooManyArguments(
                         ValueError(
@@ -362,7 +362,7 @@ def matchCall(
                     )
 
                 # Recurse into tuple argument values, could be more tuples.
-                assign(subarg, subvalue)
+                assign(sub_arg, sub_value)
 
             # Check that not too many values we provided.
             try:
@@ -379,7 +379,7 @@ def matchCall(
         return arg in assigned_tuple_params
 
     num_pos = len(positional)
-    num_total = num_pos + len(pairs)
+    num_total = num_pos + len([p for p in pairs if p[0] not in kw_only_args])
     num_args = len(args)
 
     for arg, value in zip(args, positional):

nuitka/tools/general/dll_report/__main__.py

@@ -20,7 +20,15 @@ from nuitka.utils.Timing import TimerReport
 def main():
     parser = OptionParser()
 
-    _options, positional_args = parser.parse_args()
+    parser.add_option(
+        "--no-use-path",
+        action="store_false",
+        dest="use_path",
+        default=True,
+        help="""Do NOT use PATH to locate DLL dependencies.""",
+    )
+
+    options, positional_args = parser.parse_args()
 
     if not positional_args:
         sys.exit("No DLLs given.")
@@ -45,6 +53,7 @@ def main():
                 original_dir=os.path.dirname(filename),
                 binary_filename=filename,
                 package_name=None,
+                use_path=options.use_path,
                 use_cache=False,
                 update_cache=False,
             )

nuitka/tools/onefile_compressor/OnefileCompressor.py

@@ -201,7 +201,7 @@ def _getCacheFilename(binary_filename, low_memory):
     hash_value.updateFromValues(version_string)
 
     # Take zstandard version and compression level into account.
-    from zstandard import __version__
+    from zstandard import __version__  # pylint: disable=I0021,import-error
 
     hash_value.updateFromValues(__version__, getCompressorLevel(low_memory))
 

nuitka/tools/specialize/CTypeDescriptions.py

@@ -9,6 +9,9 @@ import math
 from abc import abstractmethod
 
 from nuitka.__past__ import long
+from nuitka.code_generation.BinaryOperationHelperDefinitions import (
+    isCommutativeType,
+)
 from nuitka.code_generation.Namify import namifyConstant
 from nuitka.utils.SlotMetaClasses import getMetaClassBase
 
@@ -562,12 +565,11 @@ return %(return_value)s;""" % {
         else:
             return object_desc
 
-    def isSimilarOrSameTypesAsOneOf(self, *others):
-        for other in others:
-            assert other is not None
+    def isSimilarOrSameTypesAsOneOf(self, other):
+        assert other is not None
 
-            if self is other or other in related_types.get(self, ()):
-                return True
+        if self is other or other in related_types.get(self, ()):
+            return True
 
         return False
 
@@ -709,6 +711,10 @@ return %(return_value)s;""" % {
                 return "Py_INCREF(%s); %s = %s;" % (operand, result, operand)
             else:
                 return "%s = %s;" % (result, operand)
+        elif cls.isDualType():
+            ref_taking = "Py_INCREF(%s); " if take_ref else ""
+
+            return "%sSET_NILONG_OBJECT_VALUE(%s, %s);" % (ref_taking, result, operand)
         else:
             if take_ref:
                 return """%s = %s; """ % (
@@ -759,7 +765,7 @@ return %(return_value)s;""" % {
             # Need to not use that, but pick one.
             assert False
         elif cls.type_name == "int":
-            return "%s = PyInt_FromLong(%s);" % (result, operand)
+            return "%s = Nuitka_PyInt_FromLong(%s);" % (result, operand)
         elif cls.type_name == "long":
             return "%s = Nuitka_LongFromCLong(%s);" % (result, operand)
         elif cls.type_name == "nbool":
@@ -767,6 +773,8 @@ return %(return_value)s;""" % {
                 result,
                 cls.getToValueFromBoolExpression("%s != 0" % operand),
             )
+        elif cls.type_name == "nilong":
+            return "SET_NILONG_C_VALUE(%s, %s);" % (result, operand)
         else:
             assert False, cls
 
@@ -945,6 +953,14 @@ Py_INCREF(%(result)s);""" % {
             else:
                 assert False, cls.type_name
 
+    @classmethod
+    def isDualType(cls):
+        return False
+
+    @classmethod
+    def isCommutativeType(cls):
+        return isCommutativeType(cls.getHelperCodeName())
+
 
 class ConcreteTypeBase(TypeDescBase):
     type_decl = "PyObject *"
@@ -1447,6 +1463,12 @@ class ObjectDesc(TypeDescBase):
     def getNoSequenceSlotAccessTestCode(self, type_name):
         return "%s->tp_as_sequence == NULL" % type_name
 
+    @classmethod
+    def getDualValidityCheckCode(cls, value_choice, operand):
+        # Virtual method, pylint: disable=unused-argument
+        assert value_choice == "C", value_choice
+        return "false"
+
 
 object_desc = ObjectDesc()
 
@@ -1472,6 +1494,25 @@ class ConcreteCTypeBase(TypeDescBase):
     def hasPreferredSlot(right, slot):
         return False
 
+    @classmethod
+    def isDualType(cls):
+        return False
+
+    @classmethod
+    def getDualValidityCheckCode(cls, value_choice, operand):
+        # Virtual method, pylint: disable=unused-argument
+        assert value_choice == "C", value_choice
+        return "true"
+
+    def getDualType(self, value_choice):
+        assert value_choice == "C", value_choice
+        return self
+
+    @classmethod
+    def getDualTypeAccessCode(cls, value_choice, operand):
+        assert value_choice == "C", (value_choice, cls)
+        return operand
+
 
 class CLongDesc(ConcreteCTypeBase):
     type_name = "clong"
@@ -1496,7 +1537,7 @@ class CLongDesc(ConcreteCTypeBase):
 
     @staticmethod
     def getAsObjectValueExpression(operand):
-        return "PyLong_FromLong(%s)" % operand
+        return "Nuitka_PyLong_FromLong(%s)" % operand
 
     @staticmethod
     def releaseAsObjectValueStatement(operand):
@@ -1663,6 +1704,108 @@ class NBoolDesc(ConcreteCTypeBase):
 n_bool_desc = NBoolDesc()
 
 
+class DualTypeBase(ConcreteCTypeBase):
+    @classmethod
+    def getDualValidityCheckCode(cls, value_choice, operand):
+        if value_choice == "C":
+            helper = "IS_%s_C_VALUE_VALID" % cls.type_name.upper()
+        elif value_choice == "Python":
+            helper = "IS_%s_OBJECT_VALUE_VALID" % cls.type_name.upper()
+        else:
+            assert False
+
+        return "%s(%s)" % (helper, operand)
+
+    @classmethod
+    def getDualType(cls, value_choice):
+        if value_choice == "C":
+            return cls.type_dual_types[1]
+        elif value_choice == "Python":
+            return cls.type_dual_types[0]
+        else:
+            assert False
+
+    @classmethod
+    def getDualTypeAccessCode(cls, value_choice, operand):
+        if value_choice == "C":
+            return "%s->c_value" % operand
+        elif value_choice == "Python":
+            return "%s->python_value" % operand
+        else:
+            assert False
+
+    @classmethod
+    def getSetDualValueCode(cls, value_choice, target, value):
+        if value_choice == "C":
+            helper = "SET_%s_C_VALUE" % cls.type_name.upper()
+        elif value_choice == "Python":
+            helper = "SET_%s_OBJECT_VALUE" % cls.type_name.upper()
+        else:
+            assert False
+
+        return "%s(%s, %s);" % (helper, target, value)
+
+    @classmethod
+    def isDualType(cls):
+        return True
+
+    @classmethod
+    def getDualTypeEnsurePythonObjectCode(cls, operand):
+        return "ENFORCE_%s_OBJECT_VALUE(%s);" % (cls.type_name.upper(), operand)
+
+
+class NILongDesc(DualTypeBase):
+    type_name = "nilong"
+    type_desc = "Nuitka int/long/C long value"
+    type_decl = "nuitka_ilong *"
+
+    type_dual_types = long_desc, c_long_desc
+
+    @classmethod
+    def getCheckValueCode(cls, operand):
+        return "CHECK_NILONG_OBJECT(%s);" % operand
+
+    @classmethod
+    def getTypeValueExpression(cls, operand):
+        assert False
+        return "NULL"
+
+    @classmethod
+    def getNewStyleNumberTypeCheckExpression(cls, operand):
+        return "0"
+
+    @staticmethod
+    def getAsLongValueExpression(operand):
+        return "GET_NILONG_C_VALUE(%s)" % operand
+
+    @staticmethod
+    def getAsObjectValueExpression(operand):
+        return "GET_NILONG_OBJECT_VALUE(%s)" % operand
+
+    @staticmethod
+    def getToValueFromBoolExpression(operand):
+        assert False
+        return "%s ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE" % operand
+
+    @classmethod
+    def getToValueFromObjectExpression(cls, operand):
+        # TODO: Seems wrong, int return values only happen to match nuitka_bool here
+        return cls.getToValueFromBoolExpression("CHECK_IF_TRUE(%s)" % operand)
+
+    @staticmethod
+    def getTakeReferenceStatement(operand, immortal):
+        assert False
+        return ""
+
+    @staticmethod
+    def getExceptionResultIndicatorValue():
+        assert False
+        return "NUITKA_BOOL_EXCEPTION"
+
+
+n_ilong_desc = NILongDesc()
+
+
 class NVoidDesc(ConcreteCTypeBase):
     type_name = "nvoid"
     type_desc = "Nuitka C void value"
@@ -1755,12 +1898,18 @@ related_types = {}
 
 
 def _addRelatedTypes(type_desc_1, type_desc_2):
-    related_types[type_desc_1] = (type_desc_2,)
-    related_types[type_desc_2] = (type_desc_1,)
+    if type_desc_1 not in related_types:
+        related_types[type_desc_1] = set()
+    if type_desc_2 not in related_types:
+        related_types[type_desc_2] = set()
+
+    related_types[type_desc_1].add(type_desc_2)
+    related_types[type_desc_2].add(type_desc_1)
 
 
 _addRelatedTypes(int_desc, c_long_desc)
 _addRelatedTypes(long_desc, c_digit_desc)
+_addRelatedTypes(long_desc, c_long_desc)
 _addRelatedTypes(float_desc, c_float_desc)
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and