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

nuitka/utils/AppDirs.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
+
+
 """ Wrapper around appdirs from PyPI
 
 We do not assume to be installed and fallback to an inline copy and if that
@@ -35,15 +21,20 @@ from nuitka.Tracing import general
 from .FileOperations import makePath
 from .Importing import importFromInlineCopy
 
-appdirs = importFromInlineCopy("appdirs", must_exist=False)
+appdirs = importFromInlineCopy("appdirs", must_exist=False, delete_module=True)
 
 if appdirs is None:
     import appdirs  # pylint: disable=I0021,import-error
 
+
+def getAppdirsModule():
+    return appdirs
+
+
 _cache_dir = None
 
 
-def getCacheDir():
+def _getCacheDir():
     global _cache_dir  # singleton, pylint: disable=global-statement
 
     if _cache_dir is None:
@@ -73,8 +64,38 @@ def getCacheDir():
                 """\
 Error, failed to create cache directory '%s'. If this is due to a special environment, \
 please consider making a PR for a general solution that adds support for it, or use \
-NUITKA_CACHE_DIR set to a writable directory."""
+'NUITKA_CACHE_DIR' set to a writable directory."""
                 % _cache_dir
             )
 
     return _cache_dir
+
+
+def getCacheDirEnvironmentVariableName(cache_basename):
+    env_name = cache_basename.replace("-", "_").upper()
+
+    return "NUITKA_CACHE_DIR_" + env_name
+
+
+def getCacheDir(cache_basename):
+    cache_dir = os.getenv(getCacheDirEnvironmentVariableName(cache_basename))
+    if cache_dir is None:
+        cache_dir = os.path.join(_getCacheDir(), cache_basename)
+
+    return cache_dir
+
+
+#     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/utils/CStrings.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
+
+
 """ C string encoding
 
 This contains the code to create string literals for C to represent the given
@@ -24,7 +10,7 @@ values.
 import codecs
 import re
 
-from nuitka.__past__ import unicode
+from nuitka.__past__ import to_byte, unicode
 
 
 def _identifierEncode(c):
@@ -52,7 +38,7 @@ def _encodePythonStringToC(value):
             cv = c
 
         if c in b'\\\t\r\n"?':
-            result += r"\%o" % cv
+            result += r"\%03o" % cv
 
             octal = True
         elif 32 <= cv <= 127:
@@ -77,11 +63,23 @@ def encodePythonUnicodeToC(value):
     assert type(value) is unicode, type(value)
 
     result = ""
+    last_was_hex = False
 
     for c in value:
         cv = ord(c)
 
-        result += r"\%o" % cv
+        if c == "\\":
+            result += "\\\\"
+            last_was_hex = False
+        elif 34 < cv < 128:
+            if last_was_hex:
+                result += '" L"'
+
+            result += c
+            last_was_hex = False
+        else:
+            result += r"\x%04x" % cv
+            last_was_hex = True
 
     return 'L"%s"' % result
 
@@ -105,6 +103,37 @@ def encodePythonStringToC(value):
     return result
 
 
+def decodeCStringToPython(value):
+    assert value.startswith('"')
+    value = value[1:-1]
+
+    result = b""
+
+    while value:
+        if value[0] == "\\":
+            value = value[1:]
+            if value[0] == "\\":
+                result += b"\\"
+                continue
+
+            if value[0].isdigit():
+                assert value[1].isdigit(), value
+                assert value[2].isdigit(), value
+
+                octal_number = int(value[2]) + int(value[1]) * 8 + int(value[0]) * 64
+                value = value[3:]
+
+                result += to_byte(octal_number)
+                continue
+
+            assert False, value[0]
+
+        result += value[0].encode("ascii")
+        value = value[1:]
+
+    return result
+
+
 def encodePythonIdentifierToC(value):
     """Encode an identifier from a given Python string."""
 
@@ -120,4 +149,20 @@ def encodePythonIdentifierToC(value):
         else:
             return "$$%d$" % ord(c)
 
-    return "".join(re.sub("[^a-zA-Z0-9_]", r, c) for c in value)
+    return re.sub("[^a-zA-Z0-9_]", r, value)
+
+
+#     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/utils/CommandLineOptions.py

@@ -1,36 +1,55 @@
-#     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.
-#
-""" Tools for command line options."""
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
 
+""" Tools for command line options."""
+
 import sys
-from optparse import IndentedHelpFormatter, OptionGroup, OptionParser
+from optparse import (
+    AmbiguousOptionError,
+    BadOptionError,
+    IndentedHelpFormatter,
+    OptionGroup,
+    OptionParser,
+)
+
+from nuitka.Tracing import formatTerminalLink
 
 # For re-export only:
 from optparse import SUPPRESS_HELP  # isort:skip pylint: disable=unused-import
 
 
 class OurOptionGroup(OptionGroup):
+    def __init__(self, *args, **kwargs):
+        link = kwargs.pop("link", None)
+
+        OptionGroup.__init__(self, *args, **kwargs)
+
+        self.link = link
+
+    def format_help(self, formatter):
+        old_title = self.title
+
+        try:
+            if self.link is not None:
+                link = "https://nuitka.net/help/%s.html" % self.link
+
+                self.title = formatTerminalLink(self.title, link)
+            return OptionGroup.format_help(self, formatter)
+        finally:
+            self.title = old_title
+
     def add_option(self, *args, **kwargs):
         require_compiling = kwargs.pop("require_compiling", True)
+        github_action = kwargs.pop("github_action", True)
+        github_action_default = kwargs.pop("github_action_default", None)
+        link = kwargs.pop("github_action_default", None)
 
         result = OptionGroup.add_option(self, *args, **kwargs)
+
         result.require_compiling = require_compiling
+        result.github_action = github_action
+        result.github_action_default = github_action_default
+        result.link = link
 
         return result
 
@@ -50,19 +69,64 @@ class OurOptionParser(OptionParser):
 
         return OptionParser._process_long_opt(self, rargs, values)
 
+    def _match_long_opt(self, opt):
+        """_match_long_opt(opt : string) -> string
+
+        Determine which long option string 'opt' matches, ie. which one
+        it is an unambiguous abbreviation for.  Raises BadOptionError if
+        'opt' doesn't unambiguously match any long option string.
+
+        Nuitka: We overload it, in order avoid issues with conflicting
+        options that are really only aliases of the same option.
+        """
+        matched_options = set()
+        possibilities = []
+
+        # Exact matches are never ambiguous. We sometimes append to option names
+        # in order to detail things.
+        for option_name in self._long_opt:
+            if opt == option_name:
+                return opt
+
+        for option_name, option_obj in self._long_opt.items():
+            if option_name.startswith(opt):
+                if option_obj not in matched_options:
+                    matched_options.add(option_obj)
+                    possibilities.append(option_name)
+
+        # No exact match, so there had better be just one possibility.
+        if len(matched_options) > 1:
+            raise AmbiguousOptionError(opt, possibilities)
+
+        if possibilities:
+            assert len(possibilities) == 1, possibilities
+            return possibilities[0]
+        else:
+            raise BadOptionError(opt)
+
     def add_option(self, *args, **kwargs):
         require_compiling = kwargs.pop("require_compiling", True)
+        github_action = kwargs.pop("github_action", True)
+        github_action_default = kwargs.pop("github_action_default", None)
+
+        default_values = self.get_default_values()
 
         result = OptionParser.add_option(self, *args, **kwargs)
         result.require_compiling = require_compiling
+        result.github_action = github_action
+        result.github_action_default = github_action_default
+
+        if result.dest is not None:
+            if hasattr(default_values, result.dest):
+                assert result.default == getattr(default_values, result.dest)
 
         return result
 
-    def add_option_group(self, group):
+    def add_option_group(self, group, link=None):
         # We restrain ourselves here, pylint: disable=arguments-differ
 
         if isinstance(group, str):
-            group = OurOptionGroup(self, group)
+            group = OurOptionGroup(self, group, link=link)
         self.option_groups.append(group)
 
         return group
@@ -94,6 +158,14 @@ class OurOptionParser(OptionParser):
 
         return False
 
+    def isListOption(self, option_name):
+        for option in self.iterateOptions():
+            # Need to use private option attribute, pylint: disable=protected-access
+            if option_name in option._long_opts:
+                return option.action == "append"
+
+        return False
+
 
 class OurHelpFormatter(IndentedHelpFormatter):
     def format_option_strings(self, option):
@@ -103,7 +175,8 @@ class OurHelpFormatter(IndentedHelpFormatter):
         if option.takes_value():
             metavar = option.metavar or option.dest.upper()
             long_opts = [
-                self._long_opt_fmt % (lopt, metavar) for lopt in option._long_opts
+                self._long_opt_fmt % (long_opt, metavar)
+                for long_opt in option._long_opts
             ]
         else:
             long_opts = option._long_opts
@@ -116,3 +189,19 @@ class OurHelpFormatter(IndentedHelpFormatter):
 
 def makeOptionsParser(usage):
     return OurOptionParser(usage=usage, formatter=OurHelpFormatter())
+
+
+#     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.