Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/tree/ReformulationMultidist.py

@@ -0,0 +1,80 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Multidist re-formulation. """
+
+import os
+
+from nuitka.Options import getMainEntryPointFilenames
+from nuitka.utils.ModuleNames import makeMultidistModuleName
+
+
+def _stripPythonSuffix(filename):
+    if filename.lower().endswith(".py"):
+        return filename[:-3]
+    elif filename.lower().endswith(".pyw"):
+        return filename[:-4]
+    else:
+        return filename
+
+
+def createMultidistMainSourceCode():
+    main_filenames = getMainEntryPointFilenames()
+
+    main_basenames = [
+        _stripPythonSuffix(os.path.basename(main_filename))
+        for main_filename in main_filenames
+    ]
+
+    main_module_names = [
+        makeMultidistModuleName(count, main_basename)
+        for count, main_basename in enumerate(main_basenames, start=1)
+    ]
+
+    from nuitka.utils.Jinja2 import renderTemplateFromString
+
+    source_code = renderTemplateFromString(
+        r"""
+import sys, re, os
+main_basename = re.sub(r'(.pyw?|\.exe|\.bin)?$', '', os.path.normcase(os.path.basename(__compiled__.original_argv0)))
+{% for main_module_name, main_basename in zip(main_module_names, main_basenames) %}
+if main_basename == "{{main_basename}}":
+    __import__("{{main_module_name.asString()}}")
+    sys.exit(0)
+{% endfor %}
+
+sys.exit("Error, failed to detect what to do for filename derived name '%s'." % main_basename)
+""",
+        main_module_names=main_module_names,
+        main_basenames=main_basenames,
+        zip=zip,
+    )
+
+    return source_code
+
+
+def locateMultidistModule(module_name):
+    multidist_index = int(str(module_name).split("-")[1])
+
+    return (
+        module_name,
+        getMainEntryPointFilenames()[multidist_index - 1],
+        "py",
+        "absolute",
+    )
+
+
+#     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/tree/ReformulationNamespacePackages.py

@@ -0,0 +1,239 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+"""
+Namespace packages of Python3
+
+"""
+
+import os
+
+from nuitka.nodes.AttributeNodes import makeExpressionAttributeLookup
+from nuitka.nodes.CallNodes import ExpressionCallNoKeywords
+from nuitka.nodes.ConstantRefNodes import makeConstantRefNode
+from nuitka.nodes.ContainerMakingNodes import (
+    makeExpressionMakeList,
+    makeExpressionMakeTuple,
+    makeExpressionMakeTupleOrConstant,
+)
+from nuitka.nodes.FutureSpecs import FutureSpec
+from nuitka.nodes.ImportNodes import (
+    ExpressionImportName,
+    makeExpressionImportModuleFixed,
+    makeExpressionImportModuleNameHard,
+)
+from nuitka.nodes.ModuleAttributeNodes import ExpressionModuleAttributeFileRef
+from nuitka.nodes.ModuleNodes import CompiledPythonNamespacePackage
+from nuitka.nodes.VariableNameNodes import StatementAssignmentVariableName
+from nuitka.Options import getFileReferenceMode
+from nuitka.PythonVersions import python_version
+
+from .FutureSpecState import popFutureSpec, pushFutureSpec
+from .TreeHelpers import (
+    buildNode,
+    makeStatementsSequenceFromStatement,
+    parseSourceCodeToAst,
+)
+from .VariableClosure import completeVariableClosures
+
+
+def _makeCall(module_name, import_name, attribute_name, source_ref, *args):
+    return ExpressionCallNoKeywords(
+        called=makeExpressionAttributeLookup(
+            expression=makeExpressionImportModuleNameHard(
+                module_name=module_name,
+                import_name=import_name,
+                module_guaranteed=True,
+                source_ref=source_ref,
+            ),
+            attribute_name=attribute_name,
+            source_ref=source_ref,
+        ),
+        args=makeExpressionMakeTupleOrConstant(
+            elements=args, user_provided=True, source_ref=source_ref
+        ),
+        source_ref=source_ref,
+    )
+
+
+def _getNameSpacePathExpression(package, source_ref):
+    """Create the __path__ expression for a package."""
+
+    reference_mode = getFileReferenceMode()
+
+    if reference_mode == "original":
+        return makeConstantRefNode(
+            constant=[package.getCompileTimeDirectory()],
+            source_ref=source_ref,
+        )
+    elif reference_mode == "frozen":
+        return makeConstantRefNode(
+            constant=[],
+            source_ref=source_ref,
+        )
+    else:
+        file_ref_node = ExpressionModuleAttributeFileRef(
+            variable=package.getVariableForReference("__file__"),
+            source_ref=source_ref,
+        )
+
+        if package.isCompiledPythonNamespacePackage():
+            elements = [file_ref_node]
+        else:
+            elements = [
+                ExpressionCallNoKeywords(
+                    called=makeExpressionAttributeLookup(
+                        expression=makeExpressionImportModuleNameHard(
+                            module_name="os",
+                            import_name="path",
+                            module_guaranteed=True,
+                            source_ref=source_ref,
+                        ),
+                        attribute_name="dirname",
+                        source_ref=source_ref,
+                    ),
+                    args=makeExpressionMakeTuple(
+                        elements=(file_ref_node,),
+                        source_ref=source_ref,
+                    ),
+                    source_ref=source_ref,
+                )
+            ]
+
+        if package.canHaveExternalImports():
+            parts = package.getFullName().asString().split(".")
+
+            for count in range(len(parts)):
+                path_part = _makeCall(
+                    "os",
+                    "environ",
+                    "get",
+                    source_ref,
+                    makeConstantRefNode(
+                        constant="NUITKA_PACKAGE_%s" % "_".join(parts[: count + 1]),
+                        source_ref=source_ref,
+                    ),
+                    makeConstantRefNode(
+                        constant=os.path.sep + "not_existing", source_ref=source_ref
+                    ),
+                )
+
+                if parts[count + 1 :]:
+                    path_part = _makeCall(
+                        "os",
+                        "path",
+                        "join",
+                        source_ref,
+                        path_part,
+                        makeConstantRefNode(
+                            constant=os.path.join(*parts[count + 1 :]),
+                            source_ref=source_ref,
+                        ),
+                    )
+
+                elements.append(path_part)
+
+        return makeExpressionMakeList(elements=tuple(elements), source_ref=source_ref)
+
+
+def createPathAssignment(package, source_ref):
+    return StatementAssignmentVariableName(
+        provider=package,
+        variable_name="__path__",
+        source=_getNameSpacePathExpression(package=package, source_ref=source_ref),
+        source_ref=source_ref,
+    )
+
+
+def _getPathFinderFunction(package, source_ref):
+    # TODO: This could be a shared helper function, but we currently cannot do these.
+    ast_tree = parseSourceCodeToAst(
+        source_code="_path_finder = lambda *args, **kw: None",
+        module_name=package.getFullName(),
+        filename=source_ref.getFilename(),
+        line_offset=0,
+    )
+
+    pushFutureSpec(package.getFullName())
+    statement = buildNode(package, ast_tree.body[0], source_ref)
+    popFutureSpec()
+
+    return statement.subnode_source
+
+
+def createPython3NamespacePath(package, source_ref):
+
+    module_name = (
+        "_frozen_importlib" if python_version < 0x350 else "_frozen_importlib_external"
+    )
+
+    return StatementAssignmentVariableName(
+        provider=package,
+        variable_name="__path__",
+        source=ExpressionCallNoKeywords(
+            called=ExpressionImportName(
+                module=makeExpressionImportModuleFixed(
+                    using_module_name=package.getFullName(),
+                    module_name=module_name,
+                    value_name=module_name,
+                    source_ref=source_ref,
+                ),
+                import_name="_NamespacePath",
+                level=0,
+                source_ref=source_ref,
+            ),
+            args=makeExpressionMakeTupleOrConstant(
+                elements=(
+                    makeConstantRefNode(
+                        constant=package.getFullName().asString(),
+                        user_provided=True,
+                        source_ref=source_ref,
+                    ),
+                    _getNameSpacePathExpression(package=package, source_ref=source_ref),
+                    _getPathFinderFunction(package=package, source_ref=source_ref),
+                ),
+                user_provided=True,
+                source_ref=source_ref,
+            ),
+            source_ref=source_ref,
+        ),
+        source_ref=source_ref,
+    )
+
+
+def createNamespacePackage(module_name, reason, is_top, source_ref):
+    package = CompiledPythonNamespacePackage(
+        module_name=module_name,
+        reason=reason,
+        is_top=is_top,
+        mode="compiled",
+        future_spec=FutureSpec(use_annotations=False),
+        source_ref=source_ref,
+    )
+
+    if python_version >= 0x300:
+        statement = createPython3NamespacePath(package=package, source_ref=source_ref)
+    else:
+        statement = createPathAssignment(package, source_ref)
+
+    package.setChildBody(makeStatementsSequenceFromStatement(statement=statement))
+
+    completeVariableClosures(package)
+
+    return package
+
+
+#     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/tree/ReformulationPrintStatements.py

@@ -0,0 +1,127 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Reformulation of print statements.
+
+Consult the Developer Manual for information. TODO: Add ability to sync
+source code comments with Developer Manual sections.
+
+"""
+
+from nuitka.nodes.ComparisonNodes import ExpressionComparisonIs
+from nuitka.nodes.ConditionalNodes import makeStatementConditional
+from nuitka.nodes.ConstantRefNodes import ExpressionConstantNoneRef
+from nuitka.nodes.ImportNodes import makeExpressionImportModuleNameHard
+from nuitka.nodes.PrintNodes import StatementPrintNewline, StatementPrintValue
+from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
+from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
+
+from .ReformulationTryFinallyStatements import makeTryFinallyReleaseStatement
+from .TreeHelpers import (
+    buildNode,
+    buildNodeTuple,
+    makeStatementsSequenceFromStatements,
+)
+
+
+def buildPrintNode(provider, node, source_ref):
+    # "print" statements, should only occur with Python2.
+
+    if node.dest is not None:
+        temp_scope = provider.allocateTempScope("print")
+
+        tmp_target_variable = provider.allocateTempVariable(
+            temp_scope=temp_scope, name="target", temp_type="object"
+        )
+
+        target_default_statement = makeStatementAssignmentVariable(
+            variable=tmp_target_variable,
+            source=makeExpressionImportModuleNameHard(
+                module_name="sys",
+                import_name="stdout",
+                module_guaranteed=True,
+                source_ref=source_ref,
+            ),
+            source_ref=source_ref,
+        )
+
+        statements = [
+            makeStatementAssignmentVariable(
+                variable=tmp_target_variable,
+                source=buildNode(
+                    provider=provider, node=node.dest, source_ref=source_ref
+                ),
+                source_ref=source_ref,
+            ),
+            makeStatementConditional(
+                condition=ExpressionComparisonIs(
+                    left=ExpressionTempVariableRef(
+                        variable=tmp_target_variable, source_ref=source_ref
+                    ),
+                    right=ExpressionConstantNoneRef(source_ref=source_ref),
+                    source_ref=source_ref,
+                ),
+                yes_branch=target_default_statement,
+                no_branch=None,
+                source_ref=source_ref,
+            ),
+        ]
+
+    values = buildNodeTuple(provider=provider, nodes=node.values, source_ref=source_ref)
+
+    if node.dest is not None:
+        print_statements = [
+            StatementPrintValue(
+                dest=ExpressionTempVariableRef(
+                    variable=tmp_target_variable, source_ref=source_ref
+                ),
+                value=value,
+                source_ref=source_ref,
+            )
+            for value in values
+        ]
+
+        if node.nl:
+            print_statements.append(
+                StatementPrintNewline(
+                    dest=ExpressionTempVariableRef(
+                        variable=tmp_target_variable, source_ref=source_ref
+                    ),
+                    source_ref=source_ref,
+                )
+            )
+
+        statements.append(
+            makeTryFinallyReleaseStatement(
+                provider=provider,
+                tried=print_statements,
+                variables=(tmp_target_variable,),
+                source_ref=source_ref,
+            )
+        )
+    else:
+        statements = [
+            StatementPrintValue(dest=None, value=value, source_ref=source_ref)
+            for value in values
+        ]
+
+        if node.nl:
+            statements.append(StatementPrintNewline(dest=None, source_ref=source_ref))
+
+    return makeStatementsSequenceFromStatements(*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.