Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/Variables/__init__.py

@@ -0,0 +1,334 @@
+# MIT License
+#
+# Copyright The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""Add user-friendly customizable variables to an SCons build. """
+
+import os.path
+import sys
+from functools import cmp_to_key
+
+import SCons.Environment
+import SCons.Errors
+import SCons.Util
+import SCons.Warnings
+
+from .BoolVariable import BoolVariable  # okay
+from .EnumVariable import EnumVariable  # okay
+from .ListVariable import ListVariable  # naja
+from .PackageVariable import PackageVariable # naja
+from .PathVariable import PathVariable # okay
+
+
+class Variables:
+    """
+    Holds all the options, updates the environment with the variables,
+    and renders the help text.
+
+    If *is_global* is true, this is a singleton, create only once.
+
+    Args:
+      files (optional): List of option configuration files to load
+        (backward compatibility). If a single string is passed it is
+        automatically placed in a file list (Default value = None)
+      args (optional): dictionary to override values set from *files*.
+        (Default value = None)
+      is_global (optional): global instance? (Default value = True)
+
+    """
+    instance = None
+
+    def __init__(self, files=None, args=None, is_global=True):
+        if args is None:
+            args = {}
+        self.options = []
+        self.args = args
+        if not SCons.Util.is_List(files):
+            if files:
+                files = [files,]
+            else:
+                files = []
+        self.files = files
+        self.unknown = {}
+
+        # create the singleton instance
+        if is_global:
+            self = Variables.instance
+
+            if not Variables.instance:
+                Variables.instance=self
+
+    def _do_add(self, key, help="", default=None, validator=None, converter=None, **kwargs) -> None:
+        class Variable:
+            pass
+
+        option = Variable()
+
+        # If we get a list or a tuple, we take the first element as the
+        # option key and store the remaining in aliases.
+        if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
+            option.key = key[0]
+            option.aliases = list(key[1:])
+        else:
+            option.key = key
+            # TODO: normalize to not include key in aliases. Currently breaks tests.
+            option.aliases = [key,]
+        if not SCons.Environment.is_valid_construction_var(option.key):
+            raise SCons.Errors.UserError("Illegal Variables key `%s'" % str(option.key))
+        option.help = help
+        option.default = default
+        option.validator = validator
+        option.converter = converter
+
+        self.options.append(option)
+
+        # options might be added after the 'unknown' dict has been set up,
+        # so we remove the key and all its aliases from that dict
+        for alias in option.aliases + [option.key,]:
+            if alias in self.unknown:
+                del self.unknown[alias]
+
+    def keys(self) -> list:
+        """Returns the keywords for the options."""
+        return [o.key for o in self.options]
+
+    def Add(self, key, *args, **kwargs) -> None:
+        r""" Add an option.
+
+        Args:
+          key: the name of the variable, or a 5-tuple (or list).
+            If a tuple, and there are no additional arguments,
+            the tuple is unpacked into help, default, validator, converter.
+            If there are additional arguments, the first word of the tuple
+            is taken as the key, and the remainder as aliases.
+          \*args: optional positional arguments
+            help: optional help text for the options (Default value = "")
+            default: optional default value for option (Default value = None)
+            validator: optional function called to validate the option's value
+              (Default value = None)
+            converter: optional function to be called to convert the option's
+              value before putting it in the environment. (Default value = None)
+          \*\*kwargs: keyword args, can be the arguments from \*args or
+            arbitrary kwargs used by a variable itself
+
+        """
+        if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
+            if not (len(args) or len(kwargs)):
+                return self._do_add(*key)
+
+        return self._do_add(key, *args, **kwargs)
+
+    def AddVariables(self, *optlist) -> None:
+        """ Add a list of options.
+
+        Each list element is a tuple/list of arguments to be passed on
+        to the underlying method for adding options.
+
+        Example::
+
+            opt.AddVariables(
+                ('debug', '', 0),
+                ('CC', 'The C compiler'),
+                ('VALIDATE', 'An option for testing validation', 'notset', validator, None),
+            )
+
+        """
+
+        for o in optlist:
+            self._do_add(*o)
+
+    def Update(self, env, args=None) -> None:
+        """ Update an environment with the option variables.
+
+        Args:
+            env: the environment to update.
+            args: [optional] a dictionary of keys and values to update
+                in *env*. If omitted, uses the variables from the commandline.
+        """
+
+        values = {}
+
+        # first set the defaults:
+        for option in self.options:
+            if option.default is not None:
+                values[option.key] = option.default
+
+        # next set the value specified in the options file
+        for filename in self.files:
+            if os.path.exists(filename):
+                dir = os.path.split(os.path.abspath(filename))[0]
+                if dir:
+                    sys.path.insert(0, dir)
+                try:
+                    values['__name__'] = filename
+                    with open(filename, 'r') as f:
+                        contents = f.read()
+                    exec(contents, {}, values)
+                finally:
+                    if dir:
+                        del sys.path[0]
+                    del values['__name__']
+
+        # set the values specified on the command line
+        if args is None:
+            args = self.args
+
+        for arg, value in args.items():
+            added = False
+            for option in self.options:
+                if arg in option.aliases + [option.key,]:
+                    values[option.key] = value
+                    added = True
+            if not added:
+                self.unknown[arg] = value
+
+        # put the variables in the environment:
+        # (don't copy over variables that are not declared as options)
+        for option in self.options:
+            try:
+                env[option.key] = values[option.key]
+            except KeyError:
+                pass
+
+        # apply converters
+        for option in self.options:
+            if option.converter and option.key in values:
+                value = env.subst('${%s}'%option.key)
+                try:
+                    try:
+                        env[option.key] = option.converter(value)
+                    except TypeError:
+                        env[option.key] = option.converter(value, env)
+                except ValueError as x:
+                    raise SCons.Errors.UserError('Error converting option: %s\n%s'%(option.key, x))
+
+
+        # apply validators
+        for option in self.options:
+            if option.validator and option.key in values:
+                option.validator(option.key, env.subst('${%s}'%option.key), env)
+
+    def UnknownVariables(self) -> dict:
+        """ Returns unknown variables.
+
+        Identifies options that were not known, declared options in this object.
+        """
+        return self.unknown
+
+    def Save(self, filename, env) -> None:
+        """ Save the options to a file.
+
+        Saves all the options which have non-default settings
+        to the given file as Python expressions.  This file can
+        then be used to load the options for a subsequent run.
+        This can be used to create an option cache file.
+
+        Args:
+            filename: Name of the file to save into
+            env: the environment get the option values from
+        """
+
+        # Create the file and write out the header
+        try:
+            with open(filename, 'w') as fh:
+                # Make an assignment in the file for each option
+                # within the environment that was assigned a value
+                # other than the default. We don't want to save the
+                # ones set to default: in case the SConscript settings
+                # change you would then pick up old defaults.
+                for option in self.options:
+                    try:
+                        value = env[option.key]
+                        try:
+                            prepare = value.prepare_to_store
+                        except AttributeError:
+                            try:
+                                eval(repr(value))
+                            except KeyboardInterrupt:
+                                raise
+                            except:
+                                # Convert stuff that has a repr() that
+                                # cannot be evaluated into a string
+                                value = SCons.Util.to_String(value)
+                        else:
+                            value = prepare()
+
+                        defaultVal = env.subst(SCons.Util.to_String(option.default))
+                        if option.converter:
+                            try:
+                                defaultVal = option.converter(defaultVal)
+                            except TypeError:
+                                defaultVal = option.converter(defaultVal, env)
+
+                        if str(env.subst('${%s}' % option.key)) != str(defaultVal):
+                            fh.write('%s = %s\n' % (option.key, repr(value)))
+                    except KeyError:
+                        pass
+        except IOError as x:
+            raise SCons.Errors.UserError('Error writing options to file: %s\n%s' % (filename, x))
+
+    def GenerateHelpText(self, env, sort=None) -> str:
+        """ Generate the help text for the options.
+
+        Args:
+            env: an environment that is used to get the current values
+                of the options.
+            cmp: Either a comparison function used for sorting
+                (must take two arguments and return -1, 0 or 1)
+                or a boolean to indicate if it should be sorted.
+        """
+
+        if callable(sort):
+            options = sorted(self.options, key=cmp_to_key(lambda x, y: sort(x.key, y.key)))
+        elif sort is True:
+            options = sorted(self.options, key=lambda x: x.key)
+        else:
+            options = self.options
+
+        def format_opt(opt, self=self, env=env) -> str:
+            if opt.key in env:
+                actual = env.subst('${%s}' % opt.key)
+            else:
+                actual = None
+            return self.FormatVariableHelpText(env, opt.key, opt.help, opt.default, actual, opt.aliases)
+
+        lines = [_f for _f in map(format_opt, options) if _f]
+        return ''.join(lines)
+
+    fmt = '\n%s: %s\n    default: %s\n    actual: %s\n'
+    aliasfmt = '\n%s: %s\n    default: %s\n    actual: %s\n    aliases: %s\n'
+
+    def FormatVariableHelpText(self, env, key, help, default, actual, aliases=None) -> str:
+        if aliases is None:
+            aliases = []
+        # Don't display the key name itself as an alias.
+        aliases = [a for a in aliases if a != key]
+        if aliases:
+            return self.aliasfmt % (key, help, default, actual, aliases)
+        else:
+            return self.fmt % (key, help, default, actual)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/Warnings.py

@@ -0,0 +1,238 @@
+# MIT License
+#
+# Copyright The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""The SCons warnings framework."""
+
+import sys
+
+import SCons.Errors
+
+class SConsWarning(SCons.Errors.UserError):
+    pass
+
+class WarningOnByDefault(SConsWarning):
+    pass
+
+
+# NOTE:  If you add a new warning class, add it to the man page, too!
+# Not all warnings are defined here, some are defined in the location of use
+
+class TargetNotBuiltWarning(SConsWarning): # Should go to OnByDefault
+    pass
+
+class CacheVersionWarning(WarningOnByDefault):
+    pass
+
+class CacheWriteErrorWarning(SConsWarning):
+    pass
+
+class CorruptSConsignWarning(WarningOnByDefault):
+    pass
+
+class DependencyWarning(SConsWarning):
+    pass
+
+class DevelopmentVersionWarning(WarningOnByDefault):
+    pass
+
+class DuplicateEnvironmentWarning(WarningOnByDefault):
+    pass
+
+class FutureReservedVariableWarning(WarningOnByDefault):
+    pass
+
+class LinkWarning(WarningOnByDefault):
+    pass
+
+class MisleadingKeywordsWarning(WarningOnByDefault):
+    pass
+
+class MissingSConscriptWarning(WarningOnByDefault):
+    pass
+
+class NoObjectCountWarning(WarningOnByDefault):
+    pass
+
+class NoParallelSupportWarning(WarningOnByDefault):
+    pass
+
+class ReservedVariableWarning(WarningOnByDefault):
+    pass
+
+class StackSizeWarning(WarningOnByDefault):
+    pass
+
+class VisualCMissingWarning(WarningOnByDefault):
+    pass
+
+# Used when MSVC_VERSION and MSVS_VERSION do not point to the
+# same version (MSVS_VERSION is deprecated)
+class VisualVersionMismatch(WarningOnByDefault):
+    pass
+
+class VisualStudioMissingWarning(SConsWarning):
+    pass
+
+class FortranCxxMixWarning(LinkWarning):
+    pass
+
+
+# Deprecation warnings
+
+class FutureDeprecatedWarning(SConsWarning):
+    pass
+
+class DeprecatedWarning(SConsWarning):
+    pass
+
+class MandatoryDeprecatedWarning(DeprecatedWarning):
+    pass
+
+
+# Special case; base always stays DeprecatedWarning
+class PythonVersionWarning(DeprecatedWarning):
+    pass
+
+class DeprecatedSourceCodeWarning(FutureDeprecatedWarning):
+    pass
+
+class TaskmasterNeedsExecuteWarning(DeprecatedWarning):
+    pass
+
+class DeprecatedOptionsWarning(MandatoryDeprecatedWarning):
+    pass
+
+class DeprecatedDebugOptionsWarning(MandatoryDeprecatedWarning):
+    pass
+
+class DeprecatedMissingSConscriptWarning(DeprecatedWarning):
+    pass
+
+class ToolQtDeprecatedWarning(FutureDeprecatedWarning):
+    pass
+
+# The below is a list of 2-tuples.  The first element is a class object.
+# The second element is true if that class is enabled, false if it is disabled.
+_enabled = []
+
+# If set, raise the warning as an exception
+_warningAsException = False
+
+# If not None, a function to call with the warning
+_warningOut = None
+
+def suppressWarningClass(clazz):
+    """Suppresses all warnings of type clazz or derived from clazz."""
+    _enabled.insert(0, (clazz, False))
+
+def enableWarningClass(clazz):
+    """Enables all warnings of type clazz or derived from clazz."""
+    _enabled.insert(0, (clazz, True))
+
+def warningAsException(flag=True):
+    """Set global _warningAsExeption flag.
+
+    Args:
+        flag: value to set warnings-as-exceptions to [default: True]
+
+    Returns:
+        The previous value.
+    """
+    global _warningAsException
+    old = _warningAsException
+    _warningAsException = flag
+    return old
+
+def warn(clazz, *args):
+    """Issue a warning, accounting for SCons rules.
+
+    Check if warnings for this class are enabled.
+    If warnings are treated as exceptions, raise exception.
+    Use the global warning-emitter _warningOut, which allows selecting
+    different ways of presenting a traceback (see Script/Main.py)
+    """
+    warning = clazz(args)
+    for cls, flag in _enabled:
+        if isinstance(warning, cls):
+            if flag:
+                if _warningAsException:
+                    raise warning
+
+                if _warningOut:
+                    _warningOut(warning)
+            break
+
+def process_warn_strings(arguments):
+    """Process requests to enable/disable warnings.
+
+    The requests are strings passed to the --warn option or the
+    SetOption('warn') function.
+
+    An argument to this option should be of the form "warning-class"
+    or "no-warning-class".  The warning class is munged and has
+    the suffix "Warning" added in order to get an actual class name
+    from the classes above, which we need to pass to the
+    {enable,disable}WarningClass() functions.
+
+    For example, "deprecated" will enable the DeprecatedWarning class.
+    "no-dependency" will disable the DependencyWarning class.
+
+    As a special case, --warn=all and --warn=no-all will enable or
+    disable (respectively) the base class of all SCons warnings.
+    """
+
+    def _classmunge(s):
+        """Convert a warning argument to SConsCase.
+
+        The result is CamelCase, except "Scons" is changed to "SCons"
+        """
+        s = s.replace("-", " ").title().replace(" ", "")
+        return s.replace("Scons", "SCons")
+
+    for arg in arguments:
+        enable = True
+        if arg.startswith("no-"):
+            enable = False
+            arg = arg[len("no-") :]
+        if arg == 'all':
+            class_name = "SConsWarning"
+        else:
+            class_name = _classmunge(arg) + 'Warning'
+        try:
+            clazz = globals()[class_name]
+        except KeyError:
+            sys.stderr.write("No warning type: '%s'\n" % arg)
+        else:
+            if enable:
+                enableWarningClass(clazz)
+            elif issubclass(clazz, MandatoryDeprecatedWarning):
+                fmt = "Can not disable mandataory warning: '%s'\n"
+                sys.stderr.write(fmt % arg)
+            else:
+                suppressWarningClass(clazz)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/__init__.py

@@ -0,0 +1,9 @@
+__version__="4.3.0"
+__copyright__="Copyright (c) 2001 - 2021 The SCons Foundation"
+__developer__="bdeegan"
+__date__="Tue, 16 Nov 2021 19:09:21 +0000"
+__buildsys__="octodog"
+__revision__="559790274f66fa55251f5754de34820a29c7327a"
+__build__="559790274f66fa55251f5754de34820a29c7327a"
+# make sure compatibility is always in place
+import SCons.compat # noqa

nuitka/build/inline_copy/lib/scons-4.3.0/SCons/compat/__init__.py

@@ -0,0 +1,104 @@
+# MIT License
+#
+# Copyright The SCons Foundation
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""SCons compatibility package for old Python versions
+
+This subpackage holds modules that provide backwards-compatible
+implementations of various things from newer Python versions
+that we cannot count on because SCons still supported older Pythons.
+
+Other code will not generally reference things in this package through
+the SCons.compat namespace.  The modules included here add things to
+the builtins namespace or the global module list so that the rest
+of our code can use the objects and names imported here regardless of
+Python version. As a result, if this module is used, it should violate
+the normal convention for imports (standard library imports first,
+then program-specific imports, each ordered aplhabetically)
+and needs to be listed first.
+
+The rest of the things here will be in individual compatibility modules
+that are either: 1) suitably modified copies of the future modules that
+we want to use; or 2) backwards compatible re-implementations of the
+specific portions of a future module's API that we want to use.
+
+GENERAL WARNINGS:  Implementations of functions in the SCons.compat
+modules are *NOT* guaranteed to be fully compliant with these functions in
+later versions of Python.  We are only concerned with adding functionality
+that we actually use in SCons, so be wary if you lift this code for
+other uses.  (That said, making these more nearly the same as later,
+official versions is still a desirable goal, we just don't need to be
+obsessive about it.)
+
+We name the compatibility modules with an initial '_scons_' (for example,
+_scons_subprocess.py is our compatibility module for subprocess) so
+that we can still try to import the real module name and fall back to
+our compatibility module if we get an ImportError.  The import_as()
+function defined below loads the module as the "real" name (without the
+'_scons'), after which all of the "import {module}" statements in the
+rest of our code will find our pre-loaded compatibility module.
+"""
+
+import sys
+import importlib
+
+PYPY = hasattr(sys, 'pypy_translation_info')
+
+
+def rename_module(new, old):
+    """
+    Attempt to import the old module and load it under the new name.
+    Used for purely cosmetic name changes in Python 3.x.
+    """
+    try:
+        sys.modules[new] = importlib.import_module(old)
+        return True
+    except ImportError:
+        return False
+
+
+# Default pickle protocol. Higher protocols are more efficient/featured
+# but incompatible with older Python versions.
+# Negative numbers choose the highest available protocol.
+
+# Was pickle.HIGHEST_PROTOCOL
+# Changed to 4 so that python 3.8's not incompatible with previous versions
+# Python 3.8 introduced protocol 5 which is mainly an improvement for for out-of-band data buffers
+PICKLE_PROTOCOL = 4
+
+
+class NoSlotsPyPy(type):
+    """ Metaclass for PyPy compatitbility.
+
+    PyPy does not work well with __slots__ and __class__ assignment.
+    """
+
+    def __new__(meta, name, bases, dct):
+        if PYPY and '__slots__' in dct:
+            dct.pop('__slots__')
+        return super(NoSlotsPyPy, meta).__new__(meta, name, bases, dct)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4: