Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

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

@@ -0,0 +1,96 @@
+# 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.
+
+"""Variable type for true/false Variables.
+
+Usage example::
+
+    opts = Variables()
+    opts.Add(BoolVariable('embedded', 'build for an embedded system', 0))
+    ...
+    if env['embedded'] == 1:
+    ...
+"""
+
+from typing import Tuple, Callable
+
+import SCons.Errors
+
+__all__ = ['BoolVariable',]
+
+TRUE_STRINGS = ('y', 'yes', 'true', 't', '1', 'on' , 'all')
+FALSE_STRINGS = ('n', 'no', 'false', 'f', '0', 'off', 'none')
+
+
+def _text2bool(val) -> bool:
+    """Converts strings to True/False.
+
+    If *val* looks like it expresses a bool-like value, based on
+    the :data:`TRUE_STRINGS` and :data:`FALSE_STRINGS` tuples,
+    return the appropriate value.
+
+    This is usable as a converter function for SCons Variables.
+
+    Raises:
+        ValueError: if the string cannot be converted.
+    """
+
+    lval = val.lower()
+    if lval in TRUE_STRINGS:
+        return True
+    if lval in FALSE_STRINGS:
+        return False
+    raise ValueError("Invalid value for boolean option: %s" % val)
+
+
+def _validator(key, val, env) -> None:
+    """Validates the given value to be either true or false.
+
+    This is usable as a validator function for SCons Variables.
+
+    Raises:
+        KeyError: if key is not set in env
+        UserError: if key does not validate.
+    """
+    if not env[key] in (True, False):
+        raise SCons.Errors.UserError(
+            'Invalid value for boolean option %s: %s' % (key, env[key])
+        )
+
+
+def BoolVariable(key, help, default) -> Tuple[str, str, str, Callable, Callable]:
+    """Return a tuple describing a boolean SCons Variable.
+
+    The input parameters describe a boolean option. Returns a tuple
+    including the correct converter and validator.
+    The *help* text will have ``(yes|no)`` automatically appended to show the
+    valid values. The result is usable as input to :meth:`Add`.
+    """
+    help = '%s (yes|no)' % help
+    return (key, help, default, _validator, _text2bool)
+
+# 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/Variables/EnumVariable.py

@@ -0,0 +1,110 @@
+# 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.
+
+"""Variable type for enumeration Variables.
+
+Enumeration variables allow selection of one from a specified set of values.
+
+Usage example::
+
+    opts = Variables()
+    opts.Add(
+        EnumVariable(
+            'debug',
+            help='debug output and symbols',
+            default='no',
+            allowed_values=('yes', 'no', 'full'),
+            map={},
+            ignorecase=2,
+        )
+    )
+    ...
+    if env['debug'] == 'full':
+    ...
+"""
+
+from typing import Tuple, Callable
+
+import SCons.Errors
+
+__all__ = ['EnumVariable',]
+
+
+def _validator(key, val, env, vals) -> None:
+    if val not in vals:
+        raise SCons.Errors.UserError(
+            'Invalid value for option %s: %s.  Valid values are: %s' % (key, val, vals))
+
+
+def EnumVariable(key, help, default, allowed_values, map={}, ignorecase=0) -> Tuple[str, str, str, Callable, Callable]:
+    """Return a tuple describing an enumaration SCons Variable.
+
+    The input parameters describe an option with only certain values
+    allowed. Returns A tuple including an appropriate converter and
+    validator. The result is usable as input to :meth:`Add`.
+
+    *key* and *default* are passed directly on to :meth:`Add`.
+
+    *help* is the descriptive part of the help text,
+    and will have the allowed values automatically appended.
+
+    *allowed_values* is a list of strings, which are the allowed values
+    for this option.
+
+    The *map*-dictionary may be used for converting the input value
+    into canonical values (e.g. for aliases).
+
+    The value of *ignorecase* defines the behaviour of the validator:
+
+        * 0: the validator/converter are case-sensitive.
+        * 1: the validator/converter are case-insensitive.
+        * 2: the validator/converter is case-insensitive and the
+          converted value will always be lower-case.
+
+    The *validator* tests whether the value is in the list of allowed values.
+    The *converter* converts input values according to the given
+    *map*-dictionary (unmapped input values are returned unchanged).
+    """
+
+    help = '%s (%s)' % (help, '|'.join(allowed_values))
+    # define validator
+    if ignorecase:
+        validator = lambda key, val, env: \
+                    _validator(key, val.lower(), env, allowed_values)
+    else:
+        validator = lambda key, val, env: \
+                    _validator(key, val, env, allowed_values)
+    # define converter
+    if ignorecase == 2:
+        converter = lambda val: map.get(val.lower(), val).lower()
+    elif ignorecase == 1:
+        converter = lambda val: map.get(val.lower(), val)
+    else:
+        converter = lambda val: map.get(val, val)
+    return (key, help, default, validator, converter)
+
+# 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/Variables/ListVariable.py

@@ -0,0 +1,152 @@
+# 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.
+
+"""Variable type for list Variables.
+
+A 'list' option may either be 'all', 'none' or a list of names
+separated by comma. After the option has been processed, the option
+value holds either the named list elements, all list elements or no
+list elements at all.
+
+Usage example::
+
+    list_of_libs = Split('x11 gl qt ical')
+
+    opts = Variables()
+    opts.Add(
+        ListVariable(
+            'shared',
+            help='libraries to build as shared libraries',
+            default='all',
+            elems=list_of_libs,
+        )
+    )
+    ...
+    for lib in list_of_libs:
+        if lib in env['shared']:
+            env.SharedObject(...)
+        else:
+            env.Object(...)
+"""
+
+# Known Bug: This should behave like a Set-Type, but does not really,
+# since elements can occur twice.
+
+import collections
+from typing import Tuple, Callable
+
+import SCons.Util
+
+__all__ = ['ListVariable',]
+
+
+class _ListVariable(collections.UserList):
+    def __init__(self, initlist=None, allowedElems=None):
+        if initlist is None:
+            initlist = []
+        if allowedElems is None:
+            allowedElems = []
+        super().__init__([_f for _f in initlist if _f])
+        self.allowedElems = sorted(allowedElems)
+
+    def __cmp__(self, other):
+        return NotImplemented
+
+    def __eq__(self, other):
+        return NotImplemented
+
+    def __ge__(self, other):
+        return NotImplemented
+
+    def __gt__(self, other):
+        return NotImplemented
+
+    def __le__(self, other):
+        return NotImplemented
+
+    def __lt__(self, other):
+        return NotImplemented
+
+    def __str__(self):
+        if not len(self):
+            return 'none'
+        self.data.sort()
+        if self.data == self.allowedElems:
+            return 'all'
+        else:
+            return ','.join(self)
+
+    def prepare_to_store(self):
+        return self.__str__()
+
+def _converter(val, allowedElems, mapdict) -> _ListVariable:
+    """ """
+    if val == 'none':
+        val = []
+    elif val == 'all':
+        val = allowedElems
+    else:
+        val = [_f for _f in val.split(',') if _f]
+        val = [mapdict.get(v, v) for v in val]
+        notAllowed = [v for v in val if v not in allowedElems]
+        if notAllowed:
+            raise ValueError(
+                "Invalid value(s) for option: %s" % ','.join(notAllowed)
+            )
+    return _ListVariable(val, allowedElems)
+
+
+# def _validator(key, val, env) -> None:
+#     """ """
+#     # TODO: write validator for pgk list
+#     pass
+
+
+def ListVariable(key, help, default, names, map={}) -> Tuple[str, str, str, None, Callable]:
+    """Return a tuple describing a list SCons Variable.
+
+    The input parameters describe a 'list' option. Returns
+    a tuple including the correct converter and validator.
+    The result is usable for input to :meth:`Add`.
+
+    *help* will have text appended indicating the legal values
+    (not including any extra names from *map*).
+
+    *map* can be used to map alternative names to the ones in *names* -
+    that is, a form of alias.
+
+    A 'list' option may either be 'all', 'none' or a list of
+    names (separated by commas).
+    """
+    names_str = 'allowed names: %s' % ' '.join(names)
+    if SCons.Util.is_List(default):
+        default = ','.join(default)
+    help = '\n    '.join(
+        (help, '(all|none|comma-separated list of names)', names_str))
+    return (key, help, default, None, lambda val: _converter(val, names, map))
+
+# 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/Variables/PackageVariable.py

@@ -0,0 +1,107 @@
+# 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.
+
+"""Variable type for package Variables.
+
+To be used whenever a 'package' may be enabled/disabled and the
+package path may be specified.
+
+Given these options ::
+
+   x11=no   (disables X11 support)
+   x11=yes  (will search for the package installation dir)
+   x11=/usr/local/X11 (will check this path for existence)
+
+Can be used as a replacement for autoconf's ``--with-xxx=yyy`` ::
+
+    opts = Variables()
+    opts.Add(
+        PackageVariable(
+            key='x11',
+            help='use X11 installed here (yes = search some places)',
+            default='yes'
+        )
+    )
+    ...
+    if env['x11'] == True:
+        dir = ...  # search X11 in some standard places ...
+        env['x11'] = dir
+    if env['x11']:
+        ...  # build with x11 ...
+"""
+
+from typing import Tuple, Callable
+
+import SCons.Errors
+
+__all__ = ['PackageVariable',]
+
+ENABLE_STRINGS = ('1', 'yes', 'true',  'on', 'enable', 'search')
+DISABLE_STRINGS = ('0', 'no',  'false', 'off', 'disable')
+
+def _converter(val):
+    """ """
+    lval = val.lower()
+    if lval in ENABLE_STRINGS:
+        return True
+    if lval in DISABLE_STRINGS:
+        return False
+    return val
+
+
+def _validator(key, val, env, searchfunc) -> None:
+    """ """
+    # NB: searchfunc is currently undocumented and unsupported
+    # TODO write validator, check for path
+    import os
+
+    if env[key] is True:
+        if searchfunc:
+            env[key] = searchfunc(key, val)
+    elif env[key] and not os.path.exists(val):
+        raise SCons.Errors.UserError(
+            'Path does not exist for option %s: %s' % (key, val))
+
+
+def PackageVariable(key, help, default, searchfunc=None) -> Tuple[str, str, str, Callable, Callable]:
+    """Return a tuple describing a package list SCons Variable.
+
+    The input parameters describe a 'package list' option. Returns
+    a tuple including the correct converter and validator appended.
+    The result is usable as input to :meth:`Add` .
+
+    A 'package list' option may either be 'all', 'none' or a pathname
+    string. This information is appended to *help*.
+    """
+    # NB: searchfunc is currently undocumented and unsupported
+    help = '\n    '.join(
+        (help, '( yes | no | /path/to/%s )' % key))
+    return (key, help, default,
+            lambda k, v, e: _validator(k, v, e, searchfunc),
+            _converter)
+
+# 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/Variables/PathVariable.py

@@ -0,0 +1,158 @@
+# 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.
+
+"""Variable type for path Variables.
+
+To be used whenever a user-specified path override setting should be allowed.
+
+Arguments to PathVariable are:
+  * *key* - name of this option on the command line (e.g. "prefix")
+  * *help* - help string for option
+  * *default* - default value for this option
+  * *validator* - [optional] validator for option value.  Predefined are:
+
+    * *PathAccept* - accepts any path setting; no validation
+    * *PathIsDir* - path must be an existing directory
+    * *PathIsDirCreate* - path must be a dir; will create
+    * *PathIsFile* - path must be a file
+    * *PathExists* - path must exist (any type) [default]
+
+  The *validator* is a function that is called and which should return
+  True or False to indicate if the path is valid.  The arguments
+  to the validator function are: (*key*, *val*, *env*).  *key* is the
+  name of the option, *val* is the path specified for the option,
+  and *env* is the environment to which the Options have been added.
+
+Usage example::
+
+    opts = Variables()
+    opts.Add(
+        PathVariable(
+            'qtdir',
+            help='where the root of Qt is installed',
+            default=qtdir,
+            validator=PathIsDir,
+        )
+    )
+    opts.Add(
+        PathVariable(
+            'qt_includes',
+            help='where the Qt includes are installed',
+            default='$qtdir/includes',
+            validator=PathIsDirCreate,
+        )
+    )
+    opts.Add(
+        PathVariable(
+            'qt_libraries',
+            help='where the Qt library is installed',
+            default='$qtdir/lib',
+        )
+    )
+"""
+
+
+import os
+import os.path
+from typing import Tuple, Callable
+
+import SCons.Errors
+
+__all__ = ['PathVariable',]
+
+class _PathVariableClass:
+
+    @staticmethod
+    def PathAccept(key, val, env) -> None:
+        """Accepts any path, no checking done."""
+        pass
+
+    @staticmethod
+    def PathIsDir(key, val, env) -> None:
+        """Validator to check if Path is a directory."""
+        if not os.path.isdir(val):
+            if os.path.isfile(val):
+                m = 'Directory path for option %s is a file: %s'
+            else:
+                m = 'Directory path for option %s does not exist: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+
+    @staticmethod
+    def PathIsDirCreate(key, val, env) -> None:
+        """Validator to check if Path is a directory,
+           creating it if it does not exist."""
+        try:
+            os.makedirs(val, exist_ok=True)
+        except FileExistsError:
+            m = 'Path for option %s is a file, not a directory: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+        except PermissionError:
+            m = 'Path for option %s could not be created: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+
+    @staticmethod
+    def PathIsFile(key, val, env) -> None:
+        """Validator to check if Path is a file"""
+        if not os.path.isfile(val):
+            if os.path.isdir(val):
+                m = 'File path for option %s is a directory: %s'
+            else:
+                m = 'File path for option %s does not exist: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+
+    @staticmethod
+    def PathExists(key, val, env) -> None:
+        """Validator to check if Path exists"""
+        if not os.path.exists(val):
+            m = 'Path for option %s does not exist: %s'
+            raise SCons.Errors.UserError(m % (key, val))
+
+    def __call__(self, key, help, default, validator=None) -> Tuple[str, str, str, Callable, None]:
+        """Return a tuple describing a path list SCons Variable.
+
+        The input parameters describe a 'path list' option. Returns
+        a tuple with the correct converter and validator appended. The
+        result is usable for input to :meth:`Add`.
+
+        The *default* option specifies the default path to use if the
+        user does not specify an override with this option.
+
+        *validator* is a validator, see this file for examples
+        """
+        if validator is None:
+            validator = self.PathExists
+
+        if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
+            helpmsg = '%s ( /path/to/%s )' % (help, key[0])
+        else:
+            helpmsg = '%s ( /path/to/%s )' % (help, key)
+        return (key, helpmsg, default, validator, None)
+
+
+PathVariable = _PathVariableClass()
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4: