nova-bridgeye 0.1.1 → 0.1.3

package/.venv_build/Lib/site-packages/PyInstaller/__init__.py

@@ -0,0 +1,64 @@
+#-----------------------------------------------------------------------------
+# Copyright (c) 2005-2023, PyInstaller Development Team.
+#
+# Distributed under the terms of the GNU General Public License (version 2
+# or later) with exception for distributing the bootloader.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#
+# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
+#-----------------------------------------------------------------------------
+
+__all__ = ('HOMEPATH', 'PLATFORM', '__version__', 'DEFAULT_DISTPATH', 'DEFAULT_SPECPATH', 'DEFAULT_WORKPATH')
+
+import os
+import sys
+
+from PyInstaller import compat
+from PyInstaller.utils.git import get_repo_revision
+
+# Note: Keep this variable as plain string so it could be updated automatically when doing a release.
+__version__ = '6.10.0'
+
+# Absolute path of this package's directory. Save this early so all submodules can use the absolute path. This is
+# required for example if the current directory changes prior to loading the hooks.
+PACKAGEPATH = os.path.abspath(os.path.dirname(__file__))
+
+HOMEPATH = os.path.dirname(PACKAGEPATH)
+
+# Update __version__ as necessary.
+if os.path.exists(os.path.join(HOMEPATH, 'setup.py')):
+    # PyInstaller is run directly from source without installation, or __version__ is called from 'setup.py'...
+    if compat.getenv('PYINSTALLER_DO_RELEASE') == '1':
+        # Suppress the git revision when doing a release.
+        pass
+    elif 'sdist' not in sys.argv:
+        # and 'setup.py' was not called with 'sdist' argument. For creating source tarball we do not want git revision
+        # in the filename.
+        try:
+            __version__ += get_repo_revision()
+        except Exception:
+            # Write to stderr because stdout is used for eval() statement in some subprocesses.
+            sys.stderr.write('WARN: failed to parse git revision')
+else:
+    # PyInstaller was installed by `python setup.py install'.
+    from importlib.metadata import version
+    __version__ = version('PyInstaller')
+# Default values of paths where to put files created by PyInstaller. If changing these, do not forget to update the
+# help text for corresponding command-line options, defined in build_main.
+
+# Where to put created .spec file.
+DEFAULT_SPECPATH = os.getcwd()
+# Where to put the final frozen application.
+DEFAULT_DISTPATH = os.path.join(os.getcwd(), 'dist')
+# Where to put all the temporary files; .log, .pyz, etc.
+DEFAULT_WORKPATH = os.path.join(os.getcwd(), 'build')
+
+PLATFORM = compat.system + '-' + compat.architecture
+# Include machine name in path to bootloader for some machines (e.g., 'arm'). Explicitly avoid doing this on macOS,
+# where we keep universal2 bootloaders in Darwin-64bit folder regardless of whether we are on x86_64 or arm64.
+if compat.machine and not compat.is_darwin:
+    PLATFORM += '-' + compat.machine
+# Similarly, disambiguate musl Linux from glibc Linux.
+if compat.is_musl:
+    PLATFORM += '-musl'

package/.venv_build/Lib/site-packages/PyInstaller/__main__.py

@@ -0,0 +1,308 @@
+#-----------------------------------------------------------------------------
+# Copyright (c) 2013-2023, PyInstaller Development Team.
+#
+# Distributed under the terms of the GNU General Public License (version 2
+# or later) with exception for distributing the bootloader.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#
+# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
+#-----------------------------------------------------------------------------
+"""
+Main command-line interface to PyInstaller.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import sys
+import pathlib
+from collections import defaultdict
+
+from PyInstaller import __version__
+from PyInstaller import log as logging
+# Note: do not import anything else until compat.check_requirements function is run!
+from PyInstaller import compat
+
+try:
+    from argcomplete import autocomplete
+except ImportError:
+
+    def autocomplete(parser):
+        return None
+
+
+logger = logging.getLogger(__name__)
+
+# Taken from https://stackoverflow.com/a/22157136 to format args more flexibly: any help text which beings with ``R|``
+# will have all newlines preserved; the help text will be line wrapped. See
+# https://docs.python.org/3/library/argparse.html#formatter-class.
+
+
+# This is used by the ``--debug`` option.
+class _SmartFormatter(argparse.HelpFormatter):
+    def _split_lines(self, text, width):
+        if text.startswith('R|'):
+            # The underlying implementation of ``RawTextHelpFormatter._split_lines`` invokes this; mimic it.
+            return text[2:].splitlines()
+        else:
+            # Invoke the usual formatter.
+            return super()._split_lines(text, width)
+
+
+def run_makespec(filenames, **opts):
+    # Split pathex by using the path separator
+    temppaths = opts['pathex'][:]
+    pathex = opts['pathex'] = []
+    for p in temppaths:
+        pathex.extend(p.split(os.pathsep))
+
+    import PyInstaller.building.makespec
+
+    spec_file = PyInstaller.building.makespec.main(filenames, **opts)
+    logger.info('wrote %s' % spec_file)
+    return spec_file
+
+
+def run_build(pyi_config, spec_file, **kwargs):
+    import PyInstaller.building.build_main
+    PyInstaller.building.build_main.main(pyi_config, spec_file, **kwargs)
+
+
+def __add_options(parser):
+    parser.add_argument(
+        '-v',
+        '--version',
+        action='version',
+        version=__version__,
+        help='Show program version info and exit.',
+    )
+
+
+class _PyiArgumentParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        self._pyi_action_groups = defaultdict(list)
+        super().__init__(*args, **kwargs)
+
+    def _add_options(self, __add_options: callable, name: str = ""):
+        """
+        Mutate self with the given callable, storing any new actions added in a named group
+        """
+        n_actions_before = len(getattr(self, "_actions", []))
+        __add_options(self)  # preserves old behavior
+        new_actions = getattr(self, "_actions", [])[n_actions_before:]
+        self._pyi_action_groups[name].extend(new_actions)
+
+    def _option_name(self, action):
+        """
+        Get the option name(s) associated with an action
+
+        For options that define both short and long names, this function will
+        return the long names joined by "/"
+        """
+        longnames = [name for name in action.option_strings if name.startswith("--")]
+        if longnames:
+            name = "/".join(longnames)
+        else:
+            name = action.option_strings[0]
+        return name
+
+    def _forbid_options(self, args: argparse.Namespace, group: str, errmsg: str = ""):
+        """Forbid options from a named action group"""
+        options = defaultdict(str)
+        for action in self._pyi_action_groups[group]:
+            dest = action.dest
+            name = self._option_name(action)
+            if getattr(args, dest) is not self.get_default(dest):
+                if dest in options:
+                    options[dest] += "/"
+                options[dest] += name
+
+        # if any options from the forbidden group are not the default values,
+        # the user must have passed them in, so issue an error report
+        if options:
+            sep = "\n  "
+            bad = sep.join(options.values())
+            if errmsg:
+                errmsg = "\n" + errmsg
+            raise SystemExit(f"option(s) not allowed:{sep}{bad}{errmsg}")
+
+
+def generate_parser() -> _PyiArgumentParser:
+    """
+    Build an argparse parser for PyInstaller's main CLI.
+    """
+
+    import PyInstaller.building.build_main
+    import PyInstaller.building.makespec
+    import PyInstaller.log
+
+    parser = _PyiArgumentParser(formatter_class=_SmartFormatter)
+    parser.prog = "pyinstaller"
+
+    parser._add_options(__add_options)
+    parser._add_options(PyInstaller.building.makespec.__add_options, name="makespec")
+    parser._add_options(PyInstaller.building.build_main.__add_options, name="build_main")
+    parser._add_options(PyInstaller.log.__add_options, name="log")
+
+    parser.add_argument(
+        'filenames',
+        metavar='scriptname',
+        nargs='+',
+        help="Name of scriptfiles to be processed or exactly one .spec file. If a .spec file is specified, most "
+        "options are unnecessary and are ignored.",
+    )
+
+    return parser
+
+
+def run(pyi_args: list | None = None, pyi_config: dict | None = None):
+    """
+    pyi_args     allows running PyInstaller programmatically without a subprocess
+    pyi_config   allows checking configuration once when running multiple tests
+    """
+    compat.check_requirements()
+    check_unsafe_privileges()
+
+    import PyInstaller.log
+
+    old_sys_argv = sys.argv
+    try:
+        parser = generate_parser()
+        autocomplete(parser)
+        if pyi_args is None:
+            pyi_args = sys.argv[1:]
+        try:
+            index = pyi_args.index("--")
+        except ValueError:
+            index = len(pyi_args)
+        args = parser.parse_args(pyi_args[:index])
+        spec_args = pyi_args[index + 1:]
+        PyInstaller.log.__process_options(parser, args)
+
+        # Print PyInstaller version, Python version, and platform as the first line to stdout. This helps us identify
+        # PyInstaller, Python, and platform version when users report issues.
+        try:
+            from _pyinstaller_hooks_contrib import __version__ as contrib_hooks_version
+        except Exception:
+            contrib_hooks_version = 'unknown'
+
+        logger.info('PyInstaller: %s, contrib hooks: %s', __version__, contrib_hooks_version)
+        logger.info('Python: %s%s', platform.python_version(), " (conda)" if compat.is_conda else "")
+        logger.info('Platform: %s', platform.platform())
+        logger.info('Python environment: %s', sys.prefix)
+
+        # Skip creating .spec when .spec file is supplied.
+        if args.filenames[0].endswith('.spec'):
+            parser._forbid_options(
+                args, group="makespec", errmsg="makespec options not valid when a .spec file is given"
+            )
+            spec_file = args.filenames[0]
+        else:
+            # Ensure that the given script files exist, before trying to generate the .spec file.
+            # This prevents us from overwriting an existing (and customized) .spec file if user makes a typo in the
+            # .spec file's suffix when trying to  build it, for example, `pyinstaller program.cpes` (see #8276).
+            # It also prevents creation of a .spec file when `pyinstaller program.py` is accidentally ran from a
+            # directory that does not contain the script (for example, due to failing to change the directory prior
+            # to running the command).
+            for filename in args.filenames:
+                if not os.path.isfile(filename):
+                    raise SystemExit(f"Script file {filename!r} does not exist.")
+            spec_file = run_makespec(**vars(args))
+
+        sys.argv = [spec_file, *spec_args]
+        run_build(pyi_config, spec_file, **vars(args))
+
+    except KeyboardInterrupt:
+        raise SystemExit("Aborted by user request.")
+    except RecursionError:
+        from PyInstaller import _recursion_too_deep_message
+        _recursion_too_deep_message.raise_with_msg()
+    finally:
+        sys.argv = old_sys_argv
+
+
+def _console_script_run():
+    # Python prepends the main script's parent directory to sys.path. When PyInstaller is ran via the usual
+    # `pyinstaller` CLI entry point, this directory is $pythonprefix/bin which should not be in sys.path.
+    if os.path.basename(sys.path[0]) in ("bin", "Scripts"):
+        sys.path.pop(0)
+    run()
+
+
+def check_unsafe_privileges():
+    """
+    Forbid dangerous usage of PyInstaller with escalated privileges
+    """
+    if compat.is_win:
+        # Discourage (with the intention to eventually block) people using *run as admin* with PyInstaller.
+        # There are 4 cases, block case 3 but be careful not to also block case 2.
+        #   1. User has no admin access: TokenElevationTypeDefault
+        #   2. User is an admin/UAC disabled (common on CI/VMs): TokenElevationTypeDefault
+        #   3. User has used *run as administrator* to elevate: TokenElevationTypeFull
+        #   4. User can escalate but hasn't: TokenElevationTypeLimited
+        # See https://techcommunity.microsoft.com/t5/windows-blog-archive/how-to-determine-if-a-user-is-a-member-of-the-administrators/ba-p/228476
+        import ctypes
+
+        advapi32 = ctypes.CDLL("Advapi32.dll")
+        kernel32 = ctypes.CDLL("kernel32.dll")
+
+        kernel32.GetCurrentProcess.restype = ctypes.c_void_p
+        process = kernel32.GetCurrentProcess()
+
+        token = ctypes.c_void_p()
+        try:
+            TOKEN_QUERY = 8
+            assert advapi32.OpenProcessToken(ctypes.c_void_p(process), TOKEN_QUERY, ctypes.byref(token))
+
+            elevation_type = ctypes.c_int()
+            TokenElevationType = 18
+            assert advapi32.GetTokenInformation(
+                token, TokenElevationType, ctypes.byref(elevation_type), ctypes.sizeof(elevation_type),
+                ctypes.byref(ctypes.c_int())
+            )
+        finally:
+            kernel32.CloseHandle(token)
+
+        if elevation_type.value == 2:  # TokenElevationTypeFull
+            logger.log(
+                logging.DEPRECATION,
+                "Running PyInstaller as admin is not necessary nor sensible. Run PyInstaller from a non-administrator "
+                "terminal. PyInstaller 7.0 will block this."
+            )
+
+    elif compat.is_darwin or compat.is_linux:
+        # Discourage (with the intention to eventually block) people using *sudo* with PyInstaller.
+        # Again there are 4 cases, block only case 4.
+        #   1. Non-root: os.getuid() != 0
+        #   2. Logged in as root (usually a VM): os.getlogin() == "root", os.getuid() == 0
+        #   3. No named users (e.g. most Docker containers): os.getlogin() fails
+        #   4. Regular user using escalation: os.getlogin() != "root", os.getuid() == 0
+        try:
+            user = os.getlogin()
+        except OSError:
+            user = ""
+        if os.getuid() == 0 and user and user != "root":
+            logger.log(
+                logging.DEPRECATION,
+                "Running PyInstaller as root is not necessary nor sensible. Do not use PyInstaller with sudo. "
+                "PyInstaller 7.0 will block this."
+            )
+
+    if compat.is_win:
+        # Do not let people run PyInstaller from admin cmd's default working directory (C:\Windows\system32)
+        try:
+            pathlib.Path().resolve().relative_to(r"C:\Windows")
+        except ValueError:
+            pass
+        else:
+            raise SystemExit(
+                f"Error: Do not run pyinstaller from {pathlib.Path().resolve()}. cd to where your code is and run "
+                "pyinstaller from there. Hint: You can open a terminal where your code is by going to the parent "
+                "folder in Windows file explorer then typing cmd into the address bar."
+            )
+
+
+if __name__ == '__main__':
+    run()

package/.venv_build/Lib/site-packages/PyInstaller/_recursion_too_deep_message.py

@@ -0,0 +1,45 @@
+#-----------------------------------------------------------------------------
+# Copyright (c) 2013-2023, PyInstaller Development Team.
+#
+# Distributed under the terms of the GNU General Public License (version 2
+# or later) with exception for distributing the bootloader.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#
+# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
+#-----------------------------------------------------------------------------
+
+msg = """
+=============================================================
+A RecursionError (maximum recursion depth exceeded) occurred.
+For working around please follow these instructions
+=============================================================
+
+1. In your program's .spec file add this line near the top::
+
+     import sys ; sys.setrecursionlimit(sys.getrecursionlimit() * 5)
+
+2. Build your program by running PyInstaller with the .spec file as
+   argument::
+
+     pyinstaller myprog.spec
+
+3. If this fails, you most probably hit an endless recursion in
+   PyInstaller. Please try to track this down as far as possible,
+   create a minimal example so we can reproduce and open an issue at
+   https://github.com/pyinstaller/pyinstaller/issues following the
+   instructions in the issue template. Many thanks.
+
+Explanation: Python's stack-limit is a safety-belt against endless recursion,
+eating up memory. PyInstaller imports modules recursively. If the structure
+how modules are imported within your program is awkward, this leads to the
+nesting being too deep and hitting Python's stack-limit.
+
+With the default recursion limit (1000), the recursion error occurs at about
+115 nested imported, with limit 2000 at about 240, with limit 5000 at about
+660.
+"""
+
+
+def raise_with_msg():
+    raise SystemExit(msg)

package/.venv_build/Lib/site-packages/PyInstaller/_shared_with_waf.py

@@ -0,0 +1,86 @@
+#-----------------------------------------------------------------------------
+# Copyright (c) 2005-2023, PyInstaller Development Team.
+#
+# Distributed under the terms of the GNU General Public License (version 2
+# or later) with exception for distributing the bootloader.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#
+# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
+#-----------------------------------------------------------------------------
+"""
+Code to be shared by PyInstaller and the bootloader/wscript file.
+
+This code must not assume that either PyInstaller or any of its dependencies installed. I.e., the only imports allowed
+in here are standard library ones. Within reason, it is preferable that this file should still run under Python 2.7 as
+many compiler docker images still have only Python 2 installed.
+"""
+
+import platform
+import re
+
+
+def _pyi_machine(machine, system):
+    # type: (str, str) -> str
+    """
+    Choose an intentionally simplified architecture identifier to be used in the bootloader's directory name.
+
+    Args:
+        machine:
+            The output of ``platform.machine()`` or any known architecture alias or shorthand that may be used by a
+            C compiler.
+        system:
+            The output of ``platform.system()`` on the target machine.
+    Returns:
+        Either a string tag or, on platforms that don't need an architecture tag, ``None``.
+
+    Ideally, we would just use ``platform.machine()`` directly, but that makes cross-compiling the bootloader almost
+    impossible, because you need to know at compile time exactly what ``platform.machine()`` will be at run time, based
+    only on the machine name alias or shorthand reported by the C compiler at the build time. Rather, use a loose
+    differentiation, and trust that anyone mixing armv6l with armv6h knows what they are doing.
+    """
+    # See the corresponding tests in tests/unit/test_compat.py for examples.
+
+    if platform.machine() == "sw_64" or platform.machine() == "loongarch64":
+        # This explicitly inhibits cross compiling the bootloader for or on SunWay and LoongArch machine.
+        return platform.machine()
+
+    if system == "Windows":
+        if machine.lower().startswith("arm"):
+            return "arm"
+        else:
+            return "intel"
+
+    if system != "Linux":
+        # No architecture specifier for anything par Linux.
+        # - macOS is on two 64 bit architectures, but they are merged into one "universal2" bootloader.
+        # - BSD supports a wide range of architectures, but according to PyPI's download statistics, every one of our
+        #   BSD users are on x86_64. This may change in the distant future.
+        return
+
+    if machine.startswith(("arm", "aarch")):
+        # ARM has a huge number of similar and aliased sub-versions, such as armv5, armv6l armv8h, aarch64.
+        return "arm"
+    if machine in ("thumb"):
+        # Reported by waf/gcc when Thumb instruction set is enabled on 32-bit ARM. The platform.machine() returns "arm"
+        # regardless of the instruction set.
+        return "arm"
+    if machine in ("x86_64", "x64", "x86"):
+        return "intel"
+    if re.fullmatch("i[1-6]86", machine):
+        return "intel"
+    if machine.startswith(("ppc", "powerpc")):
+        # PowerPC comes in 64 vs 32 bit and little vs big endian variants.
+        return "ppc"
+    if machine in ("mips64", "mips"):
+        return "mips"
+    if machine.startswith("riscv"):
+        return "riscv"
+    # Machines with no known aliases :)
+    if machine in ("s390x",):
+        return machine
+
+    # Unknown architectures are allowed by default, but will all be placed under one directory. In theory, trying to
+    # have multiple unknown architectures in one copy of PyInstaller will not work, but that should be sufficiently
+    # unlikely to ever happen.
+    return "unknown"

package/.venv_build/Lib/site-packages/PyInstaller/archive/__init__.py

@@ -0,0 +1 @@
+__author__ = 'martin'

package/.venv_build/Lib/site-packages/PyInstaller/archive/pyz_crypto.py

@@ -0,0 +1,16 @@
+#-----------------------------------------------------------------------------
+# Copyright (c) 2005-2023, PyInstaller Development Team.
+#
+# Distributed under the terms of the GNU General Public License (version 2
+# or later) with exception for distributing the bootloader.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#
+# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
+#-----------------------------------------------------------------------------
+
+
+class PyiBlockCipher:
+    def __init__(self, key=None):
+        from PyInstaller.exceptions import RemovedCipherFeatureError
+        raise RemovedCipherFeatureError("Please remove cipher and block_cipher parameters from your spec file.")