def _set_up_run(self, **envvars):
"""Set up common elements of a QProcess run"""
self.process = QProcess()
environment = QProcessEnvironment(self.environment)
for k, v in envvars.items():
environment.insert(k, v)
self.process.setProcessEnvironment(environment)
self.process.setProcessChannelMode(QProcess.MergedChannels)
def _set_up_run(self, **envvars):
"""Run the process with the command and args"""
self.process = QProcess(self)
environment = QProcessEnvironment(self.environment)
for k, v in envvars.items():
environment.insert(k, v)
self.process.setProcessEnvironment(environment)
self.process.setProcessChannelMode(QProcess.MergedChannels)
def launch_game(app_name: str,
lgd_core: LegendaryCore,
offline: bool = False,
skip_version_check: bool = False,
username_override=None,
wine_bin: str = None,
wine_prfix: str = None,
language: str = None,
wrapper=None,
no_wine: bool = os.name == "nt",
extra: [] = None):
game = lgd_core.get_installed_game(app_name)
if not game:
print("Game not found")
return None
if game.is_dlc:
print("Game is dlc")
return None
if not os.path.exists(game.install_path):
print("Game doesn't exist")
return None
if not offline:
print("logging in")
if not lgd_core.login():
return None
if not skip_version_check and not core.is_noupdate_game(app_name):
# check updates
try:
latest = lgd_core.get_asset(app_name, update=True)
except ValueError:
print("Metadata doesn't exist")
return None
if latest.build_version != game.version:
print("Please update game")
return None
params, cwd, env = lgd_core.get_launch_parameters(app_name=app_name,
offline=offline,
extra_args=extra,
user=username_override,
wine_bin=wine_bin,
wine_pfx=wine_prfix,
language=language,
wrapper=wrapper,
disable_wine=no_wine)
process = QProcess()
process.setWorkingDirectory(cwd)
environment = QProcessEnvironment()
for e in env:
environment.insert(e, env[e])
process.setProcessEnvironment(environment)
process.start(params[0], params[1:])
return process
def __main_execution(self):
self.__current_process = self.main_process
if not self.only_text:
# In case a text is executed and not a file or project
file_directory = file_manager.get_folder(self.filename)
self.main_process.setWorkingDirectory(file_directory)
self.main_process.setProgram(self.python_exec)
self.main_process.setArguments(self.arguments)
environment = QProcessEnvironment()
system_environment = self.main_process.systemEnvironment()
for env in system_environment:
key, value = env.split("=", 1)
environment.insert(key, value)
self.main_process.setProcessEnvironment(environment)
self.main_process.start()
def __main_execution(self):
python_exec = self.python_exec
file_directory = file_manager.get_folder(self._filename)
self._process.setWorkingDirectory(file_directory)
# Force python to unbuffer stding ad stdout
options = ['-u'] + settings.EXECUTION_OPTIONS.split()
self._process.setProgram(python_exec)
self._process.setArguments(options + [self._filename])
environment = QProcessEnvironment()
system_environemnt = self._process.systemEnvironment()
for env in system_environemnt:
key, value = env.split('=', 1)
environment.insert(key, value)
self._process.setProcessEnvironment(environment)
self._process.start()
def run(self, *args, cwd=None):
env = QProcessEnvironment().systemEnvironment()
for k, v in self.get_subprocess_env().items():
env.insert(k, v)
self.process = QProcess(self)
self.process.setProcessEnvironment(env)
if cwd:
self.process.setWorkingDirectory(cwd)
# self.process.stateChanged.connect(self.stateChanged)
self.process.readyReadStandardOutput.connect(self.on_stdout_read)
self.process.readyReadStandardError.connect(self.on_stderr_read)
self.process.finished.connect(self.on_process_end)
self.clear()
self.process.start(args[0], args[1:], QIODevice.ReadWrite)
def __main_execution(self):
self._current_process = self._process
file_directory = file_manager.get_folder(self._filename)
self._process.setWorkingDirectory(file_directory)
# Force python to unbuffer stding ad stdout
options = ['-u'] + settings.EXECUTION_OPTIONS.split()
# Set python exec and arguments
program_params = [
param.strip() for param in self._params.split(',') if param
]
self._process.setProgram(self.python_exec)
self._process.setArguments(options + [self._filename] + program_params)
environment = QProcessEnvironment()
system_environemnt = self._process.systemEnvironment()
for env in system_environemnt:
key, value = env.split('=', 1)
environment.insert(key, value)
self._process.setProcessEnvironment(environment)
# Start!
self._process.start()
def __main_execution(self):
"""Execute the project."""
self.output.setCurrentCharFormat(self.output.plain_format)
message = ''
if self.__preScriptExecuted:
self.__preScriptExecuted = False
message = self.tr(
"Pre Execution Script Successfully executed.\n\n")
self.output.setPlainText(message + 'Running: %s (%s)\n\n' %
(self.fileName, time.ctime()))
self.output.moveCursor(QTextCursor.Down)
self.output.moveCursor(QTextCursor.Down)
self.output.moveCursor(QTextCursor.Down)
if not self.pythonExec:
self.pythonExec = settings.PYTHON_EXEC
#change the working directory to the fileName dir
file_directory = file_manager.get_folder(self.fileName)
self._proc.setWorkingDirectory(file_directory)
#force python to unbuffer stdin and stdout
options = ['-u'] + settings.EXECUTION_OPTIONS.split()
self.currentProcess = self._proc
env = QProcessEnvironment()
system_environemnt = self._proc.systemEnvironment()
for e in system_environemnt:
key, value = e.split('=', 1)
env.insert(key, value)
if self.PYTHONPATH:
envpaths = [path for path in self.PYTHONPATH.splitlines()]
for path in envpaths:
env.insert('PYTHONPATH', path)
env.insert('PYTHONIOENCODING', 'utf-8')
env.insert('PYTHONPATH', ':'.join(sys.path))
self._proc.setProcessEnvironment(env)
self._proc.start(
self.pythonExec, options + [self.fileName] +
[p.strip() for p in self.programParams.split(',') if p])
def launch_game(core,
app_name: str,
offline: bool = False,
skip_version_check: bool = False):
game = core.get_installed_game(app_name)
if not game:
print("Game not found")
return None
if game.is_dlc:
print("Game is dlc")
return None
if not os.path.exists(game.install_path):
print("Game doesn't exist")
return None
if not offline:
if not skip_version_check and not core.is_noupdate_game(app_name):
# check updates
try:
latest = core.get_asset(app_name, update=True)
except ValueError:
print("Metadata doesn't exist")
return None
if latest.build_version != game.version:
print("Please update game")
return None
params, cwd, env = core.get_launch_parameters(app_name=app_name,
offline=offline)
process = QProcess()
process.setWorkingDirectory(cwd)
environment = QProcessEnvironment()
for e in env:
environment.insert(e, env[e])
process.setProcessEnvironment(environment)
process.start(params[0], params[1:])
return process
def __startProcess(self, program, arguments, environment=None):
"""
Private method to start the debugger client process.
@param program name of the executable to start (string)
@param arguments arguments to be passed to the program (list of string)
@param environment dictionary of environment settings to pass
(dict of string)
@return the process object (QProcess) or None
"""
proc = QProcess()
if environment is not None:
env = QProcessEnvironment()
for key, value in list(environment.items()):
env.insert(key, value)
proc.setProcessEnvironment(env)
args = []
for arg in arguments:
args.append(arg)
proc.start(program, args)
if not proc.waitForStarted(10000):
proc = None
return proc
def _start(self, args, env):
"""Actually start the process."""
executable, exec_args = self._executable_args()
if args is None:
args = self._default_args()
if env is None:
procenv = QProcessEnvironment.systemEnvironment()
else:
procenv = QProcessEnvironment()
for k, v in env.items():
procenv.insert(k, v)
passthrough_vars = ['DISPLAY', 'HOME'] # so --no-xvfb works
for var in passthrough_vars:
if var in os.environ:
procenv.insert(var, os.environ[var])
self.proc.readyRead.connect(self.read_log)
self.proc.setProcessEnvironment(procenv)
self.proc.start(executable, exec_args + args)
ok = self.proc.waitForStarted()
assert ok
assert self.is_running()
