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

nuitka/code_generation/CodeObjectCodes.py

@@ -1,20 +1,6 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Code generation for code objects.
 
 Right now only the creation is done here. But more should be added later on.
@@ -22,6 +8,7 @@ Right now only the creation is done here. But more should be added later on.
 
 import os
 
+from nuitka.__past__ import unicode
 from nuitka.Options import getFileReferenceMode
 from nuitka.PythonVersions import python_version
 
@@ -36,7 +23,7 @@ def getCodeObjectsDeclCode(context):
 
     if context.getOwner().getFullName() == "__main__":
         statements.append('/* For use in "MainProgram.c". */')
-        statements.append("PyCodeObject *codeobj_main = NULL;")
+        statements.append("PyCodeObject *code_objects_main = NULL;")
 
     return statements
 
@@ -83,12 +70,16 @@ def _getMakeCodeObjectArgs(code_object_handle, context):
         " | ".join(co_flags) or "0",
         context.getConstantCode(constant=code_object_handle.co_name),
         context.getConstantCode(constant=code_object_handle.co_qualname),
-        context.getConstantCode(constant=code_object_handle.co_varnames)
-        if code_object_handle.co_varnames
-        else "NULL",
-        context.getConstantCode(constant=code_object_handle.co_freevars)
-        if code_object_handle.co_freevars
-        else "NULL",
+        (
+            context.getConstantCode(constant=code_object_handle.co_varnames)
+            if code_object_handle.co_varnames
+            else "NULL"
+        ),
+        (
+            context.getConstantCode(constant=code_object_handle.co_freevars)
+            if code_object_handle.co_freevars
+            else "NULL"
+        ),
         code_object_handle.co_argcount,
         code_object_handle.co_kwonlyargcount,
         code_object_handle.co_posonlyargcount,
@@ -113,8 +104,11 @@ def getCodeObjectsInitCode(context):
     else:
         template = "module_filename_obj = MAKE_RELATIVE_PATH(%s); CHECK_OBJECT(module_filename_obj);"
 
+    if str is bytes and type(module_filename) is unicode:
+        module_filename = module_filename.encode("utf8")
+
     # The code object will not work from any other type, cannot be e.g. unicode.
-    assert type(module_filename) is str, type(module_filename)
+    assert type(module_filename) is str, (type(module_filename), module_filename)
 
     statements.append(template % (context.getConstantCode(constant=module_filename)))
 
@@ -133,6 +127,22 @@ def getCodeObjectsInitCode(context):
 
         if context.getOwner().getFullName() == "__main__":
             if code_object_key[1] == "<module>":
-                statements.append("codeobj_main = %s;" % code_identifier)
+                statements.append("code_objects_main = %s;" % code_identifier)
 
     return statements
+
+
+#     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.

nuitka/code_generation/ComparisonCodes.py

@@ -1,27 +1,17 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Comparison related codes.
 
 Rich comparisons, "in", and "not in", also "is", and "is not", and the
 "isinstance" check as used in conditions, as well as exception matching.
 """
 
-from nuitka.nodes.shapes.BuiltinTypeShapes import tshape_bool
+from nuitka.nodes.shapes.BuiltinTypeShapes import (
+    tshape_bool,
+    tshape_frozenset,
+    tshape_set,
+)
 from nuitka.nodes.shapes.StandardShapes import tshape_unknown
 from nuitka.PythonOperators import (
     comparison_inversions,
@@ -83,7 +73,12 @@ def getRichComparisonCode(
         right_shape,
         left_c_type,
         right_c_type,
-    ) = decideExpressionCTypes(left=left, right=right, may_swap_arguments="always")
+    ) = decideExpressionCTypes(
+        left=left,
+        right=right,
+        may_swap_arguments="always",
+        context=context,
+    )
 
     if unknown_types:
         assert not needs_argument_swap
@@ -192,9 +187,13 @@ def getRichComparisonCode(
     if needs_argument_swap:
         arg1_name = right_name
         arg2_name = left_name
+        arg1_c_type = right_c_type
+        arg2_c_type = left_c_type
     else:
         arg1_name = left_name
         arg2_name = right_name
+        arg1_c_type = left_c_type
+        arg2_c_type = right_c_type
 
     # May need to convert return value.
     if helper_type is not target_type:
@@ -207,11 +206,13 @@ def getRichComparisonCode(
         value_name = to_name
 
     emit(
-        "%s = %s(%s, %s);"
+        "%s = %s(%s%s, %s%s);"
         % (
             value_name,
             helper_function,
+            "&" if arg1_c_type.isDualType() else "",
             arg1_name,
+            "&" if arg2_c_type.isDualType() else "",
             arg2_name,
         )
     )
@@ -293,9 +294,21 @@ def generateComparisonExpressionCode(to_name, expression, emit, context):
 
         res_name = context.getIntResName()
 
+        right_shape = right.getTypeShape()
+
+        if right_shape in (tshape_set, tshape_frozenset):
+            c_api = "PySet_Contains"
+        else:
+            c_api = "PySequence_Contains"
+
         emit(
-            "%s = PySequence_Contains(%s, %s);"
-            % (res_name, right_name, left_name)  # sequence goes first in the API.
+            "%s = %s(%s, %s);"
+            % (
+                res_name,
+                c_api,
+                right_name,
+                left_name,
+            )  # sequence goes first in the API.
         )
 
         getErrorExitBoolCode(
@@ -538,3 +551,19 @@ def generateMatchTypeCheckSequenceCode(to_name, expression, emit, context):
     to_name.getCType().emitAssignmentCodeFromBoolCondition(
         to_name=to_name, condition="%s" % res_name, emit=emit
     )
+
+
+#     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.

nuitka/code_generation/ComparisonHelperDefinitions.py

@@ -1,20 +1,6 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Shared definitions of what comparison operation helpers are available.
 
 These are functions to work with helper names, as well as sets of functions to
@@ -58,6 +44,10 @@ def _makeTypeOps(type_name, may_raise_same_type, shortcut=False):
             if result_part == "CBOOL":
                 continue
 
+            # TODO: We want those as well, but we don't need them immediately.
+            if type_name in ("NILONG",):
+                continue
+
             yield "RICH_COMPARE_%s_%s_OBJECT_%s" % (comparator, result_part, type_name)
             yield "RICH_COMPARE_%s_%s_%s_OBJECT" % (comparator, result_part, type_name)
 
@@ -79,7 +69,7 @@ def _makeTypeOps(type_name, may_raise_same_type, shortcut=False):
             )
 
 
-def _makeFriendOps(type_name1, type_name2, may_raise):
+def _makeFriendOps(type_name1, type_name2, may_raise, shortcut):
     assert type_name1 != type_name2
 
     for result_part in "OBJECT", "CBOOL", "NBOOL":
@@ -87,7 +77,11 @@ def _makeFriendOps(type_name1, type_name2, may_raise):
             if result_part == "NBOOL":
                 continue
 
-        for comparator in rich_comparison_codes.values():
+        for comparator in (
+            rich_comparison_codes.values()
+            if not shortcut
+            else rich_comparison_subset_codes.values()
+        ):
             yield "RICH_COMPARE_%s_%s_%s_%s" % (
                 comparator,
                 result_part,
@@ -106,15 +100,22 @@ specialized_cmp_helpers_set = buildOrderedSet(
     _makeTypeOps("INT", may_raise_same_type=False, shortcut=True),
     _makeTypeOps("LONG", may_raise_same_type=False, shortcut=True),
     _makeTypeOps("FLOAT", may_raise_same_type=False, shortcut=True),
+    # Dual types
+    _makeTypeOps("NILONG", may_raise_same_type=False, shortcut=True),
     # TODO: What would shortcut mean, how do tuples compare their elements then?
-    _makeTypeOps("TUPLE", may_raise_same_type=True),
-    _makeTypeOps("LIST", may_raise_same_type=True),
+    _makeTypeOps("TUPLE", may_raise_same_type=True, shortcut=False),
+    _makeTypeOps("LIST", may_raise_same_type=True, shortcut=False),
     # Mixed Python types:
-    _makeFriendOps("LONG", "INT", may_raise=False),
+    # TODO: Absolutely possible to shortcut, why aren't we doing it?
+    _makeFriendOps("LONG", "INT", may_raise=False, shortcut=False),
     # Partial Python with C types
-    _makeFriendOps("INT", "CLONG", may_raise=False),
-    _makeFriendOps("LONG", "DIGIT", may_raise=False),
-    _makeFriendOps("FLOAT", "CFLOAT", may_raise=False),
+    # TODO: Absolutely possible to shortcut, why aren't we doing it?
+    _makeFriendOps("INT", "CLONG", may_raise=False, shortcut=False),
+    _makeFriendOps("LONG", "DIGIT", may_raise=False, shortcut=False),
+    _makeFriendOps("FLOAT", "CFLOAT", may_raise=False, shortcut=False),
+    # Partial dual types with C types, cannot shortcut as reverse argument versions are used.
+    _makeFriendOps("NILONG", "CLONG", may_raise=False, shortcut=False),
+    _makeFriendOps("NILONG", "DIGIT", may_raise=False, shortcut=False),
     # TODO: Add "CLONG_CLONG" type ops once we use that for local variables too.
 )
 
@@ -127,3 +128,19 @@ def getSpecializedComparisonOperations():
 
 def getNonSpecializedComparisonOperations():
     return _non_specialized_cmp_helpers_set
+
+
+#     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.

nuitka/code_generation/ConditionalCodes.py

@@ -1,20 +1,6 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Conditional statements related codes.
 
 Branches, conditions, truth checks.
@@ -232,3 +218,19 @@ def generateConditionalCode(to_name, expression, emit, context):
 
     context.setTrueBranchTarget(old_true_target)
     context.setFalseBranchTarget(old_false_target)
+
+
+#     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.

nuitka/code_generation/ConstantCodes.py

@@ -1,20 +1,6 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Low level constant code generation.
 
 This deals with constants, there creation, there access, and some checks about
@@ -31,9 +17,16 @@ import os
 import sys
 
 from nuitka import Options
+from nuitka.__past__ import unicode
+from nuitka.containers.Namedtuples import makeNamedtupleClass
+from nuitka.ModuleRegistry import getRootTopModule
 from nuitka.PythonVersions import python_version
-from nuitka.Serialization import ConstantAccessor
-from nuitka.utils.Distributions import getDistributionTopLevelPackageNames
+from nuitka.Serialization import GlobalConstantAccessor
+from nuitka.utils.CStrings import encodePythonStringToC
+from nuitka.utils.Distributions import (
+    getDistribution,
+    getDistributionTopLevelPackageNames,
+)
 from nuitka.Version import getNuitkaVersionTuple
 
 from .CodeHelpers import withObjectCodeTemporaryAssignment
@@ -98,7 +91,7 @@ def getConstantsDefinitionCode():
     """
     # Somewhat detail rich, pylint: disable=too-many-locals
 
-    constant_accessor = ConstantAccessor(
+    constant_accessor = GlobalConstantAccessor(
         data_filename="__constants.const", top_level_name="global_constants"
     )
 
@@ -141,7 +134,19 @@ def getConstantsDefinitionCode():
                 sys.base_exec_prefix
             )
 
-    metadata_values_code = constant_accessor.getConstantCode(metadata_values)
+    runtime_metadata_values = tuple(
+        (
+            distribution_name,
+            (
+                metadata_value.module_name,
+                metadata_value.metadata,
+                metadata_value.entry_points_data,
+            ),
+        )
+        for distribution_name, metadata_value in sorted(metadata_values.items())
+    )
+
+    metadata_values_code = constant_accessor.getConstantCode(runtime_metadata_values)
 
     lines.insert(
         0,
@@ -157,6 +162,9 @@ def getConstantsDefinitionCode():
     major, minor, micro, is_final, _rc_number = getNuitkaVersionTuple()
 
     body = template_constants_reading % {
+        "module_name_cstr": encodePythonStringToC(
+            getRootTopModule().getFullName().asString().encode("utf8")
+        ),
         "global_constants_count": constant_accessor.getConstantsCount(),
         "sys_executable": sys_executable,
         "sys_prefix": sys_prefix,
@@ -173,17 +181,63 @@ def getConstantsDefinitionCode():
     return header, body
 
 
+MetaDataDescription = makeNamedtupleClass(
+    "MetaDataDescription",
+    (
+        "module_name",
+        "metadata",
+        "entry_points_data",
+        "reasons",
+    ),
+)
+
 metadata_values = {}
 
 
-def addDistributionMetadataValue(name, distribution):
+def addDistributionMetadataValue(distribution_name, distribution, reason):
+    assert type(distribution_name) in (str, unicode), distribution_name
+
     # Extract what we need to from the distribution object.
-    metadata = str(
-        distribution.read_text("METADATA") or distribution.read_text("PKG-INFO") or ""
-    )
+    if distribution_name not in metadata_values:
+        # The user doesn't have this handy.
+        if distribution is None:
+            distribution = getDistribution(distribution_name)
+
+        metadata = str(
+            distribution.read_text("METADATA")
+            or distribution.read_text("PKG-INFO")
+            or ""
+        )
 
-    entry_points = str(distribution.read_text("entry_points.txt") or "")
+        entry_points_data = str(distribution.read_text("entry_points.txt") or "")
+
+        module_name = getDistributionTopLevelPackageNames(distribution)[0]
+
+        metadata_values[distribution_name] = MetaDataDescription(
+            module_name=module_name,
+            metadata=metadata,
+            entry_points_data=entry_points_data,
+            reasons=[reason],
+        )
+    else:
+        metadata_values[distribution_name].reasons.append(reason)
 
-    package_name = getDistributionTopLevelPackageNames(distribution)[0]
 
-    metadata_values[name] = (package_name, metadata, entry_points)
+def getDistributionMetadataValues():
+    return sorted(metadata_values.items())
+
+
+#     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.