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

nuitka/specs/ParameterSpecs.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
+
+
 """ This module maintains the parameter specification classes.
 
 These are used for function, lambdas, generators. They are also a factory
@@ -150,12 +136,12 @@ class ParameterSpec(object):
             "ps_normal_args": ",".join(self.normal_args),
             "ps_pos_only_args": self.pos_only_args,
             "ps_kw_only_args": ",".join(self.kw_only_args),
-            "ps_list_star_arg": self.list_star_arg
-            if self.list_star_arg is not None
-            else "",
-            "ps_dict_star_arg": self.dict_star_arg
-            if self.dict_star_arg is not None
-            else "",
+            "ps_list_star_arg": (
+                self.list_star_arg if self.list_star_arg is not None else ""
+            ),
+            "ps_dict_star_arg": (
+                self.dict_star_arg if self.dict_star_arg is not None else ""
+            ),
             "ps_default_count": self.default_count,
             "type_shape": self.type_shape,
         }
@@ -364,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(
@@ -376,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:
@@ -393,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):
@@ -405,24 +391,30 @@ def matchCall(
             try:
                 arg_index = (args + kw_only_args).index(pair[0])
             except ValueError:
-                if improved or python_version >= 0x370:
-                    message = "'%s' is an invalid keyword argument for %s()" % (
-                        pair[0],
-                        func_name,
-                    )
+                if python_version < 0x370 and not improved:
+                    template = "'%(arg_name)s' is an invalid keyword argument for this function"
+                elif python_version < 0x3D0 and not improved:
+                    template = "'%(arg_name)s' is an invalid keyword argument for %(func_name)s()"
                 else:
-                    message = (
-                        "'%s' is an invalid keyword argument for this function"
-                        % pair[0]
-                    )
+                    template = "%(func_name)s() got an unexpected keyword argument '%(arg_name)s'"
+
+                message = template % {
+                    "arg_name": pair[0],
+                    "func_name": func_name,
+                }
 
                 raise TooManyArguments(TypeError(message))
 
             if arg_index < num_pos_only:
-                message = "'%s' is an invalid keyword argument for %s()" % (
-                    pair[0],
-                    func_name,
-                )
+                if python_version < 0x3D0:
+                    template = "'%(arg_name)s' is an invalid keyword argument for %(func_name)s()"
+                else:
+                    template = "%(func_name)s() got an unexpected keyword argument '%(arg_name)s'"
+
+                message = template % {
+                    "arg_name": pair[0],
+                    "func_name": func_name,
+                }
 
                 raise TooManyArguments(TypeError(message))
 
@@ -460,9 +452,14 @@ def matchCall(
                 )
             )
 
+        if python_version < 0x3D0:
+            template = "%s() takes at most %d %s (%d given)"
+        else:
+            template = "%s expected at most %d %s, got %d"
+
         raise TooManyArguments(
             TypeError(
-                "%s() takes at most %d %s (%d given)"
+                template
                 % (
                     func_name,
                     num_args,
@@ -521,7 +518,7 @@ def matchCall(
     elif pairs:
         unexpected = next(iter(dict(pairs)))
 
-        if improved:
+        if improved or python_version >= 0x3D0:
             message = "%s() got an unexpected keyword argument '%s'" % (
                 func_name,
                 unexpected,
@@ -570,9 +567,11 @@ def matchCall(
                 "%s expected %s%s, got %d"
                 % (
                     func_name,
-                    ("at least " if python_version < 0x300 else "")
-                    if num_defaults > 0
-                    else "exactly ",
+                    (
+                        ("at least " if python_version < 0x300 else "")
+                        if num_defaults > 0
+                        else "exactly "
+                    ),
                     "%d arguments" % num_required,
                     num_total,
                 )
@@ -598,3 +597,19 @@ def matchCall(
         )
 
     return result
+
+
+#     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/specs/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     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.
-#
-""" Dummy file to make this directory a package. """

nuitka/tools/Basics.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
+
+
 """ Basics for Nuitka tools.
 
 """
@@ -49,5 +35,21 @@ def setupPATH():
 
 
 def addPYTHONPATH(path):
-    python_path = os.environ.get("PYTHONPATH", "")
+    python_path = os.getenv("PYTHONPATH", "")
     os.environ["PYTHONPATH"] = os.pathsep.join(python_path.split(os.pathsep) + [path])
+
+
+#     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/tools/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     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.
-#
-""" Dummy file to make this directory a package. """

nuitka/tools/commercial/__init__.py

@@ -1,5 +1,10 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Commercial tools package.
+
+"""
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,7 +19,3 @@
 #     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.
-#
-""" Commercial tools package.
-
-"""

nuitka/tools/data_composer/DataComposer.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
+
+
 """Data composer, crunch constants into binary blobs to load. """
 
 import binascii
@@ -28,12 +14,7 @@ from nuitka.__past__ import BytesIO, long, to_byte, unicode, xrange
 from nuitka.build.DataComposerInterface import deriveModuleConstantsBlobName
 from nuitka.Builtins import builtin_exception_values_list, builtin_named_values
 from nuitka.containers.OrderedDicts import OrderedDict
-from nuitka.PythonVersions import (
-    isPythonValidCLongLongValue,
-    isPythonValidCLongValue,
-    python_version,
-    sizeof_clonglong,
-)
+from nuitka.PythonVersions import python_version
 from nuitka.Serialization import (
     BlobData,
     BuiltinAnonValue,
@@ -46,6 +27,25 @@ from nuitka.Tracing import data_composer_logger
 from nuitka.utils.FileOperations import getFileSize, listDir, syncFileOutput
 from nuitka.utils.Json import writeJsonToFilename
 
+_max_uint64_t_value = 2**64 - 1
+_max_uint31_t_value = 2**31 - 1
+
+
+def _encodeVariableLength(value):
+    """Get the variable length size encoding of a uint64_t value."""
+
+    assert 0 <= value <= _max_uint64_t_value
+
+    result = b""
+
+    while value >= 128:
+        # Need to take the last seven bits as a byte value
+        result += to_byte((value & 255) | 128)
+        value >>= 7
+
+    # Last byte or whole value small enough.
+    return result + to_byte(value)
+
 
 def scanConstFiles(build_dir):
     result = []
@@ -90,27 +90,24 @@ def _writeConstantValue(output, constant_value):
     elif constant_value is False:
         output.write(b"F")
     elif constant_type is tuple:
-        # TODO: Optimize for size of tuple to be < 256 with dedicated value
-        output.write(b"T" + struct.pack("i", len(constant_value)))
+        output.write(b"T" + _encodeVariableLength(len(constant_value)))
 
         _last_written = None
 
         for element in constant_value:
             _writeConstantValue(output, element)
     elif constant_type is list:
-        # TODO: Optimize for size of list to be < 256 with dedicated value
-        output.write(b"L" + struct.pack("i", len(constant_value)))
+        output.write(b"L" + _encodeVariableLength(len(constant_value)))
 
         _last_written = None
 
         for element in constant_value:
             _writeConstantValue(output, element)
     elif constant_type is dict:
-        # TODO: Optimize for size of dict to be < 256 with dedicated value
-        output.write(b"D" + struct.pack("i", len(constant_value)))
+        output.write(b"D" + _encodeVariableLength(len(constant_value)))
 
         # Write keys first, and values second, such that we allow for the
-        # last_writte to have an impact.
+        # last_written to have an impact.
         items = constant_value.items()
 
         _last_written = None
@@ -121,48 +118,48 @@ def _writeConstantValue(output, constant_value):
         for key, value in items:
             _writeConstantValue(output, value)
     elif constant_type is set:
-        # TODO: Optimize for size of set to be < 256 with dedicated value
-        output.write(b"S" + struct.pack("i", len(constant_value)))
+        output.write(b"S" + _encodeVariableLength(len(constant_value)))
 
         _last_written = None
         for element in constant_value:
             _writeConstantValue(output, element)
     elif constant_type is frozenset:
-        # TODO: Optimize for size of set to be < 256 with dedicated value
-        output.write(b"P" + struct.pack("i", len(constant_value)))
+        output.write(b"P" + _encodeVariableLength(len(constant_value)))
 
         _last_written = None
         for element in constant_value:
             _writeConstantValue(output, element)
     elif constant_type is long:
-        if isPythonValidCLongValue(constant_value):
-            output.write(b"l" + struct.pack("l", constant_value))
-        elif isPythonValidCLongLongValue(constant_value):
-            output.write(b"q" + struct.pack("q", constant_value))
-        else:
-            output.write(b"g")
+        is_negative = constant_value < 0
+        abs_constant_value = abs(constant_value)
 
-            if constant_value < 0:
-                abs_constant_value = abs(constant_value)
-                output.write(b"-")
-            else:
-                abs_constant_value = constant_value
-                output.write(b"+")
+        if abs_constant_value < _max_uint31_t_value:
+            output.write(
+                (b"q" if is_negative else b"l")
+                + _encodeVariableLength(abs_constant_value)
+            )
+        else:
+            output.write(b"G" if is_negative else b"g")
 
             parts = []
 
-            mod_value = 2 ** (sizeof_clonglong * 8)
+            mod_value = 2**31
             while abs_constant_value > 0:
                 parts.append(abs_constant_value % mod_value)
-                abs_constant_value >>= sizeof_clonglong * 8
+                abs_constant_value >>= 31
 
-            output.write(struct.pack("i", len(parts)))
+            output.write(_encodeVariableLength(len(parts)))
             for part in reversed(parts):
-                output.write(struct.pack("Q", part))
+                output.write(_encodeVariableLength(part))
 
     elif constant_type is int:
-        # This is Python2 then. TODO: Special case smaller values.
-        output.write(b"i" + struct.pack("l", constant_value))
+        is_negative = constant_value < 0
+        abs_constant_value = abs(constant_value)
+        # This is Python2 then.
+
+        output.write(
+            (b"I" if is_negative else b"i") + _encodeVariableLength(abs_constant_value)
+        )
     elif constant_type is float:
         if constant_value == 0.0:
             if copysign(1, constant_value) == 1:
@@ -191,7 +188,7 @@ def _writeConstantValue(output, constant_value):
             output.write(b"w" + encoded)
         # Zero termination if possible.
         elif b"\0" in encoded:
-            output.write(b"v" + struct.pack("i", len(encoded)))
+            output.write(b"v" + _encodeVariableLength(len(encoded)))
             output.write(encoded)
         else:
             if str is not bytes and _isAttributeName(constant_value):
@@ -205,7 +202,7 @@ def _writeConstantValue(output, constant_value):
             output.write(b"d" + constant_value)
         # Zero termination if possible.
         elif b"\0" in constant_value:
-            output.write(b"b" + struct.pack("i", len(constant_value)))
+            output.write(b"b" + _encodeVariableLength(len(constant_value)))
             output.write(constant_value)
         else:
             if str is bytes and _isAttributeName(constant_value):
@@ -228,6 +225,8 @@ def _writeConstantValue(output, constant_value):
         _writeConstantValue(output, constant_value.step)
     elif constant_type is xrange:
         output.write(b";")
+        _last_written = None
+
         range_args = [
             int(v)
             for v in str(constant_value)[7 if str is bytes else 6 : -1].split(",")
@@ -241,7 +240,9 @@ def _writeConstantValue(output, constant_value):
         if len(range_args) < 3:
             range_args.append(1)
 
-        output.write(struct.pack("lll", *range_args))
+        _writeConstantValue(output, range_args[0])
+        _writeConstantValue(output, range_args[1])
+        _writeConstantValue(output, range_args[2])
     elif constant_type is complex:
         # Some float values do not transport well, use float streaming then.
         if (
@@ -262,7 +263,7 @@ def _writeConstantValue(output, constant_value):
             output.write(struct.pack("dd", constant_value.real, constant_value.imag))
 
     elif constant_type is bytearray:
-        output.write(b"B" + struct.pack("i", len(constant_value)))
+        output.write(b"B" + _encodeVariableLength(len(constant_value)))
 
         if python_version < 0x270:
             constant_value = constant_value.decode("latin1")
@@ -276,10 +277,10 @@ def _writeConstantValue(output, constant_value):
     elif constant_type is BlobData:
         constant_value = constant_value.getData()
         output.write(b"X")
-        output.write(struct.pack("i", len(constant_value)))
+        output.write(_encodeVariableLength(len(constant_value)))
         output.write(constant_value)
     elif constant_type is BuiltinGenericAliasValue:
-        output.write(b"G")
+        output.write(b"A")
         _last_written = None
         _writeConstantValue(output, constant_value.origin)
         _writeConstantValue(output, constant_value.args)
@@ -296,7 +297,7 @@ def _writeConstantValue(output, constant_value):
         output.write(constant_value.__name__.encode("utf8"))
         output.write(b"\0")
     else:
-        assert False, constant_value
+        assert False, (type(constant_value), constant_value)
 
     _last_written = constant_value
 
@@ -382,7 +383,7 @@ def main():
     # many details, mostly needed for reporting: pylint: disable=too-many-locals
 
     data_composer_logger.is_quiet = (
-        os.environ.get("NUITKA_DATA_COMPOSER_VERBOSE", "0") != "1"
+        os.getenv("NUITKA_DATA_COMPOSER_VERBOSE", "0") != "1"
     )
 
     # Internal tool, most simple command line handling. This is the build directory
@@ -422,8 +423,7 @@ def main():
             )
 
             if str is not bytes:
-                # Encoding needs to match generated source code output.
-                encoded_name = name.encode("latin1")
+                encoded_name = name.encode("utf8")
             else:
                 encoded_name = name
 
@@ -447,3 +447,19 @@ def main():
     writeJsonToFilename(stats_filename, contents=stats)
 
     sys.exit(0)
+
+
+#     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/tools/data_composer/__init__.py

@@ -1,5 +1,8 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Dummy file to make this directory a package. """
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #
@@ -14,5 +17,3 @@
 #     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.
-#
-""" Dummy file to make this directory a package. """

nuitka/tools/data_composer/__main__.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
+
+
 """ Internal tool, assemble a constants blob for Nuitka from module constants.
 
 """
@@ -38,3 +24,18 @@ if __name__ == "__main__":
     from nuitka.tools.data_composer.DataComposer import main
 
     main()
+
+#     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/tools/environments/CreateEnvironment.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
+
+
 """ For creating virtual environments.
 
 This can create empty virtualenv, but also populate them with packages from
@@ -51,6 +37,7 @@ def createEnvironmentFromReport(environment_folder, report_filename):
 
     with withVirtualenv(
         os.path.basename(environment_folder),
+        logger=tools_logger,
         base_dir=containing_folder,
         style="blue",
         delete=False,
@@ -64,3 +51,19 @@ def createEnvironmentFromReport(environment_folder, report_filename):
                 )
 
         venv.runCommand("pip install -r requirements.txt", style="blue")
+
+
+#     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.