def run_compiled_script(binary_path): args = [binary_path] exit_code = run_process(args) if exit_code: raise RuntimeError( "Failure while executing compiled script: {}".format(binary_path)) log.info("")
def execute_script(script_path): args = [sys.executable, script_path] exit_code = run_process(args) if exit_code: raise RuntimeError( "Failure while executing script: {}".format(script_path)) log.info("")
def install_wheel(wheel_path): log.info("Installing wheel: {}".format(wheel_path)) exit_code = run_process( [sys.executable, "-m", "pip", "install", wheel_path]) log.info("") if exit_code: raise RuntimeError( "Error while installing wheel {}".format(wheel_path))
def run_make(): args = [] if is_unix(): executable = "make" else: executable = "nmake" args.append(executable) exit_code = run_process(args) if exit_code: raise RuntimeError("Failure while running {}.".format(executable)) log.info("")
def compile_using_pyinstaller(): src_path = os.path.join("..", "hello.py") spec_path = os.path.join("..", "hello_app.spec") exit_code = run_process([sys.executable, "-m", "PyInstaller", spec_path]) # to create the spec file, this setting was used: #"--name=hello_app", "--console", "--log-level=DEBUG", src_path]) # By using a spec file, we avoid all the probing that might disturb certain # platforms and also save some analysis time. if exit_code: # 2019-04-28 Raising on error is again enabled raise_error_pyinstaller( "Failure while compiling script using PyInstaller.") log.info("")
def compile_using_pyinstaller(): src_path = os.path.join("..", "hello.py") spec_path = os.path.join("..", "hello_app.spec") exit_code = run_process([sys.executable, "-m", "PyInstaller", spec_path]) # to create the spec file, this setting was used: #"--name=hello_app", "--console", "--log-level=DEBUG", src_path]) # By using a spec file, we avoid all the probing that might disturb certain # platforms and also save some analysis time. if exit_code: # raise RuntimeError("Failure while compiling script using PyInstaller.") print("PYINST: Failure while compiling script using PyInstaller.") print("PYINST: sys.version = {}".format( sys.version.splitlines()[0])) print("PYINST: platform.platform() = {}".format(platform.platform())) print("PYINST: See the error message above.") return False log.info("") return True
def generate_build_cmake(): args = [CMAKE_PATH] if is_unix(): args.extend(["-G", "Unix Makefiles"]) else: args.extend(["-G", "NMake Makefiles"]) args.append("-DCMAKE_BUILD_TYPE=Release") args.append("-Dpython_interpreter={}".format(sys.executable)) # Specify prefix path so find_package(Qt5) works. qmake_dir = os.path.abspath(os.path.join(os.path.dirname(QMAKE_PATH), "..")) args.append("-DCMAKE_PREFIX_PATH={}".format(qmake_dir)) args.append("..") exit_code = run_process(args) if exit_code: raise RuntimeError("Failure while running cmake.") log.info("")
def generate_build_qmake(): exit_code = run_process( [QMAKE_PATH, "..", "python_interpreter={}".format(sys.executable)]) if exit_code: raise RuntimeError("Failure while running qmake.") log.info("")
def run_setup(self): """ Decide what kind of build is requested and then execute it. In the top-level invocation case, the script will spawn setup.py again (possibly multiple times). In the internal invocation case, the script will run setuptools.setup(). """ # Prepare initial config. config.init_config(build_type=OPTION_BUILD_TYPE, internal_build_type=OPTION_INTERNAL_BUILD_TYPE, cmd_class_dict=cmd_class_dict, package_version=get_package_version(), ext_modules=get_setuptools_extension_modules(), setup_script_dir=self.setup_script_dir, quiet=OPTION_QUIET) # This is an internal invocation of setup.py, so start actual # build. if config.is_internal_invocation(): if config.internal_build_type not in config.get_allowed_internal_build_values( ): raise RuntimeError( "Invalid '{}' option given to --internal-build-type. ". format(config.internal_build_type)) self.run_setuptools_setup() return # This is a top-level invocation of setup.py, so figure out what # modules we will build and depending on that, call setup.py # multiple times with different arguments. if config.build_type not in config.get_allowed_top_level_build_values( ): raise RuntimeError( "Invalid '{}' option given to --build-type. ".format( config.build_type)) # Build everything: shiboken2, shiboken2-generator and PySide2. if config.is_top_level_build_all(): self.add_setup_internal_invocation( config.shiboken_module_option_name) # Reuse the shiboken build for the generator package instead # of rebuilding it again. self.add_setup_internal_invocation( config.shiboken_generator_option_name, reuse_build=True) self.add_setup_internal_invocation(config.pyside_option_name) elif config.is_top_level_build_shiboken_module(): self.add_setup_internal_invocation( config.shiboken_module_option_name) elif config.is_top_level_build_shiboken_generator(): self.add_setup_internal_invocation( config.shiboken_generator_option_name) elif config.is_top_level_build_pyside(): self.add_setup_internal_invocation(config.pyside_option_name) for cmd in self.invocations_list: cmd_as_string = " ".join(cmd) print("\nRunning process: {}\n".format(cmd_as_string)) exit_code = run_process(cmd) if exit_code != 0: msg = textwrap.dedent(""" setup.py invocation failed with exit code: {}.\n\n setup.py invocation was: {} """).format(exit_code, cmd_as_string) raise RuntimeError(msg)