def _create_process(
self,
installer: InstallerTypes = "pip",
):
process = QProcess()
if installer != "pip":
process.setProgram(installer)
else:
process.setProgram(self._sys_executable_or_bundled_python())
process.setProcessChannelMode(QProcess.MergedChannels)
process.readyReadStandardOutput.connect(
lambda process=process: self._on_stdout_ready(process)
)
# setup process path
env = QProcessEnvironment()
combined_paths = os.pathsep.join(
[user_site_packages(), env.systemEnvironment().value("PYTHONPATH")]
)
env.insert("PYTHONPATH", combined_paths)
# use path of parent process
env.insert(
"PATH", QProcessEnvironment.systemEnvironment().value("PATH")
)
process.setProcessEnvironment(env)
self.set_output_widget(self._output_widget)
process.finished.connect(
lambda ec, es: self._on_process_finished(process, ec, es)
) # FIXME connecting lambda to finished signal is bug creating and may end with segfault when garbage
# collection will consume Installer object before process end.
return process
def __init__(self, cmd_list, environ=None):
"""
Process worker based on a QProcess for non blocking UI.
Parameters
----------
cmd_list : list of str
Command line arguments to execute.
environ : dict
Process environment,
"""
super(ProcessWorker, self).__init__()
self._result = None
self._cmd_list = cmd_list
self._fired = False
self._communicate_first = False
self._partial_stdout = None
self._started = False
self._timer = QTimer()
self._process = QProcess()
self._set_environment(environ)
self._timer.setInterval(150)
self._timer.timeout.connect(self._communicate)
self._process.readyReadStandardOutput.connect(self._partial)
def start(self):
filename = to_text_string(self.filecombo.currentText())
self.process = QProcess(self)
self.process.setProcessChannelMode(QProcess.SeparateChannels)
self.process.setWorkingDirectory(osp.dirname(filename))
self.process.readyReadStandardOutput.connect(self.read_output)
self.process.readyReadStandardError.connect(
lambda: self.read_output(error=True))
self.process.finished.connect(
lambda ec, es=QProcess.ExitStatus: self.finished(ec, es))
self.stop_button.clicked.connect(self.process.kill)
self.output = ''
self.error_output = ''
plver = PYLINT_VER
if plver is not None:
if plver.split('.')[0] == '0':
p_args = ['-i', 'yes']
else:
# Option '-i' (alias for '--include-ids') was removed in pylint
# 1.0
p_args = ["--msg-template='{msg_id}:{line:3d},"\
"{column}: {obj}: {msg}"]
p_args += [osp.basename(filename)]
else:
p_args = [osp.basename(filename)]
self.process.start(PYLINT_PATH, p_args)
running = self.process.waitForStarted()
self.set_running_state(running)
if not running:
QMessageBox.critical(self, _("Error"),
_("Process failed to start"))
def start_transport(self):
"""Start transport layer."""
logger.info('Starting transport for {1}: {0}'.format(
' '.join(self.transport_args), self.language))
# Create transport process
self.transport = QProcess(self)
env = self.transport.processEnvironment()
# Most LSP servers spawn other processes other than Python, which may
# require some environment variables
if self.language != 'python' and self.stdio:
for var in os.environ:
env.insert(var, os.environ[var])
logger.info('Transport process env variables: {0}'.format(
env.keys()))
self.transport.setProcessEnvironment(env)
# Set up transport
self.transport.errorOccurred.connect(self.handle_process_errors)
if self.stdio:
self.transport.setProcessChannelMode(QProcess.SeparateChannels)
if self.transport_log_file is not None:
self.transport.setStandardErrorFile(self.transport_log_file)
else:
self.transport.setProcessChannelMode(QProcess.MergedChannels)
if self.transport_log_file is not None:
self.transport.setStandardOutputFile(self.transport_log_file)
# Start transport
self.transport.start(self.transport_args[0], self.transport_args[1:])
def _main(args):
# import pydm
# app = QApplication([])
# app = pydm.PyDMApplication()
app = QApplication([])
signal.signal(signal.SIGINT, signal.SIG_DFL)
from xicam.gui.windows import splash
from xicam.core import msg
if args.verbose in sys.argv:
QErrorMessage.qtHandler()
# start splash in subprocess
splash_proc = QProcess()
# splash_proc.started.connect(lambda: print('started splash'))
# splash_proc.finished.connect(lambda: print('finished splashing'))
log_file = msg.file_handler.baseFilename
initial_length = os.path.getsize(log_file)
splash_proc.start(sys.executable,
[splash.__file__, log_file,
str(initial_length)])
from xicam.gui.windows.mainwindow import XicamMainWindow
mainwindow = XicamMainWindow()
while splash_proc.state() != QProcess.NotRunning:
app.processEvents()
# splash_proc.waitForFinished()
mainwindow.show()
# splash = splash.XicamSplashScreen(args=args)
return sys.exit(app.exec_())
def start(self):
filename = to_text_string(self.filecombo.currentText())
self.process = QProcess(self)
self.process.setProcessChannelMode(QProcess.SeparateChannels)
self.process.setWorkingDirectory(osp.dirname(filename))
self.process.readyReadStandardOutput.connect(self.read_output)
self.process.readyReadStandardError.connect(
lambda: self.read_output(error=True))
self.process.finished.connect(
lambda ec, es=QProcess.ExitStatus: self.finished(ec, es))
self.stop_button.clicked.connect(self.process.kill)
self.output = ''
self.error_output = ''
clver = COALA_VER
if clver is not None:
c_args = ['-m', 'run_coala']
self.process.start(sys.executable, c_args)
running = self.process.waitForStarted()
self.set_running_state(running)
if not running:
QMessageBox.critical(self, _("Error"),
_("Process failed to start"))
def __init__(self, parent, jack_client, jack_name=PROGRAM):
QDialog.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.fFreewheel = False
self.fLastTime = -1
self.fMaxTime = 180
self.fTimer = QTimer(self)
self.fProcess = QProcess(self)
self.fJackClient = jack_client
self.fJackName = jack_name
self.fBufferSize = self.fJackClient.get_buffer_size()
self.fSampleRate = self.fJackClient.get_sample_rate()
# Selected ports used as recording sources
self.rec_sources = set()
self.createUi()
self.loadSettings()
self.populatePortLists(init=True)
# listen to changes to JACK ports
self._refresh_timer = None
self.fJackClient.ports_changed.connect(self.slot_refreshPortsLists)
def __init__(self, parent=None):
super().__init__(parent)
self.setup_ui()
self.setAttribute(Qt.WA_DeleteOnClose)
# create install process
self.process = QProcess(self)
self.process.setProgram(sys.executable)
self.process.setProcessChannelMode(QProcess.MergedChannels)
# setup process path
env = QProcessEnvironment()
combined_paths = os.pathsep.join(
[user_site_packages(), env.systemEnvironment().value("PYTHONPATH")]
)
env.insert("PYTHONPATH", combined_paths)
self.process.setProcessEnvironment(env)
# connections
self.install_button.clicked.connect(self._install)
self.uninstall_button.clicked.connect(self._uninstall)
self.process.readyReadStandardOutput.connect(self._on_stdout_ready)
from ..plugins import plugin_manager
self.process.finished.connect(plugin_manager.discover)
self.process.finished.connect(plugin_manager.prune)
def __init__(self,
cmd_list,
parse=False,
pip=False,
callback=None,
extra_kwargs={}):
super(ProcessWorker, self).__init__()
self._result = None
self._cmd_list = cmd_list
self._parse = parse
self._pip = pip
self._conda = not pip
self._callback = callback
self._fired = False
self._communicate_first = False
self._partial_stdout = None
self._extra_kwargs = extra_kwargs
self._timer = QTimer()
self._process = QProcess()
self._timer.setInterval(150)
self._timer.timeout.connect(self._communicate)
# self._process.finished.connect(self._communicate)
self._process.readyReadStandardOutput.connect(self._partial)
def _start(self):
"""Start the code analysis."""
self.start_spinner()
self.output = ""
self.error_output = ""
self._process = process = QProcess(self)
process.setProcessChannelMode(QProcess.SeparateChannels)
process.setWorkingDirectory(getcwd_or_home())
process.readyReadStandardOutput.connect(self._read_output)
process.readyReadStandardError.connect(
lambda: self._read_output(error=True))
process.finished.connect(
lambda ec, es=QProcess.ExitStatus: self._finished(ec, es))
command_args = self.get_command(self.get_filename())
processEnvironment = QProcessEnvironment()
processEnvironment.insert("PYTHONIOENCODING", "utf8")
# resolve spyder-ide/spyder#14262
if running_in_mac_app():
pyhome = os.environ.get("PYTHONHOME")
processEnvironment.insert("PYTHONHOME", pyhome)
process.setProcessEnvironment(processEnvironment)
process.start(sys.executable, command_args)
running = process.waitForStarted()
if not running:
self.stop_spinner()
QMessageBox.critical(
self,
_("Error"),
_("Process failed to start"),
)
def _create_process(
self,
installer: InstallerTypes = "pip",
):
process = QProcess()
process.setProcessChannelMode(QProcess.MergedChannels)
process.readyReadStandardOutput.connect(
lambda process=process: self._on_stdout_ready(process))
env = QProcessEnvironment.systemEnvironment()
if installer == "pip":
process.setProgram(self._sys_executable_or_bundled_python())
# patch process path
combined_paths = os.pathsep.join([
user_site_packages(),
env.systemEnvironment().value("PYTHONPATH"),
])
env.insert("PYTHONPATH", combined_paths)
else:
process.setProgram(installer)
if installer == "mamba":
from ..._version import version_tuple
# To avoid napari version changing when installing a plugin, we
# add a pin to the current napari version, that way we can
# restrict any changes to the actual napari application.
# Conda/mamba also pin python by default, so we effectively
# constrain python and napari versions from changing, when
# installing plugins inside the constructor bundled application.
# See: https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-pkgs.html#preventing-packages-from-updating-pinning
napari_version = ".".join(str(v) for v in version_tuple[:3])
if env.contains("CONDA_PINNED_PACKAGES"):
# str delimiter is '&'
system_pins = f"&{env.value('CONDA_PINNED_PACKAGES')}"
else:
system_pins = ""
env.insert(
"CONDA_PINNED_PACKAGES",
f"napari={napari_version}{system_pins}",
)
if os.name == "nt":
# workaround https://github.com/napari/napari/issues/4247, 4484
if not env.contains("TEMP"):
temp = gettempdir()
env.insert("TMP", temp)
env.insert("TEMP", temp)
if not env.contains("USERPROFILE"):
env.insert("HOME", os.path.expanduser("~"))
env.insert("USERPROFILE", os.path.expanduser("~"))
process.setProcessEnvironment(env)
self.set_output_widget(self._output_widget)
process.finished.connect(
lambda ec, es: self._on_process_finished(process, ec, es)
) # FIXME connecting lambda to finished signal is bug creating and may end with segfault when garbage
# collection will consume Installer object before process end.
return process
def start_server(self):
"""Start server."""
# This is not necessary if we're trying to connect to an
# external server
if self.external_server or self.stdio:
return
logger.info('Starting server: {0}'.format(' '.join(self.server_args)))
# Create server process
self.server = QProcess(self)
env = self.server.processEnvironment()
# Adjustments for the Python language server.
if self.language == 'python':
# Set the PyLS current working to an empty dir inside
# our config one. This avoids the server to pick up user
# files such as random.py or string.py instead of the
# standard library modules named the same.
cwd = osp.join(get_conf_path(), 'lsp_paths', 'cwd')
if not osp.exists(cwd):
os.makedirs(cwd)
if os.name == "nt":
# On Windows, some modules (notably Matplotlib)
# cause exceptions if they cannot get the user home.
# So, we need to pass the USERPROFILE env variable to
# the PyLSP.
if "USERPROFILE" in os.environ:
env.insert("USERPROFILE", os.environ["USERPROFILE"])
# The PyLSP can't start on pip installations if APPDATA
# is missing and the user has installed their packages on
# that directory.
# Fixes spyder-ide/spyder#17661
if (not (is_anaconda() or is_pynsist())
and "APPDATA" in os.environ):
env.insert("APPDATA", os.environ["APPDATA"])
else:
# There's no need to define a cwd for other servers.
cwd = None
# Most LSP servers spawn other processes, which may require
# some environment variables.
for var in os.environ:
env.insert(var, os.environ[var])
logger.info('Server process env variables: {0}'.format(env.keys()))
# Setup server
self.server.setProcessEnvironment(env)
self.server.errorOccurred.connect(self.handle_process_errors)
self.server.setWorkingDirectory(cwd)
self.server.setProcessChannelMode(QProcess.MergedChannels)
if self.server_log_file is not None:
self.server.setStandardOutputFile(self.server_log_file)
# Start server
self.server.start(self.server_args[0], self.server_args[1:])
def restart(self):
"""Restart the napari application in a detached process."""
process = QProcess()
process.setProgram(sys.executable)
if not running_as_bundled_app():
process.setArguments(sys.argv)
process.startDetached()
self.close(quit_app=True)
def start_server(self, filename, interpreter):
"""
Start a notebook server asynchronously.
Start a server which can render the given notebook and return
immediately. Assume the server uses the given interpreter. The manager
will check periodically whether the server is accepting requests and
emit `sig_server_started` or `sig_server_timed_out` when appropriate.
Parameters
----------
filename : str
File name of notebook to be rendered by the server.
interpreter : str
File name of Python interpreter to be used.
"""
home_dir = get_home_dir()
if filename.startswith(home_dir):
nbdir = home_dir
else:
nbdir = osp.dirname(filename)
logger.debug('Starting new notebook server for %s', nbdir)
process = QProcess(None)
serverscript = osp.join(osp.dirname(__file__), '../server/main.py')
serverscript = osp.normpath(serverscript)
arguments = [
serverscript, '--no-browser', '--notebook-dir={}'.format(nbdir),
'--NotebookApp.password='******'--KernelSpecManager.kernel_spec_class={}'.format(KERNELSPEC)
]
if self.dark_theme:
arguments.append('--dark')
logger.debug('Arguments: %s', repr(arguments))
if DEV:
env = QProcessEnvironment.systemEnvironment()
env.insert('PYTHONPATH', osp.dirname(get_module_path('spyder')))
process.setProcessEnvironment(env)
server_process = ServerProcess(process,
notebook_dir=nbdir,
interpreter=interpreter)
process.setProcessChannelMode(QProcess.MergedChannels)
process.readyReadStandardOutput.connect(
lambda: self.read_server_output(server_process))
process.errorOccurred.connect(
lambda error: self.handle_error(server_process, error))
process.finished.connect(lambda code, status: self.handle_finished(
server_process, code, status))
process.start(sys.executable, arguments)
self.servers.append(server_process)
self._check_server_started(server_process)
def start_server(self):
"""Start server."""
# This is not necessary if we're trying to connect to an
# external server
if self.external_server or self.stdio:
return
logger.info('Starting server: {0}'.format(' '.join(self.server_args)))
# Create server process
self.server = QProcess(self)
env = self.server.processEnvironment()
# Use local PyLS instead of site-packages one.
if DEV or running_under_pytest():
running_in_ci = bool(os.environ.get('CI'))
if os.name != 'nt' or os.name == 'nt' and not running_in_ci:
env.insert('PYTHONPATH', os.pathsep.join(sys.path)[:])
# Adjustments for the Python language server.
if self.language == 'python':
# Set the PyLS current working to an empty dir inside
# our config one. This avoids the server to pick up user
# files such as random.py or string.py instead of the
# standard library modules named the same.
cwd = osp.join(get_conf_path(), 'lsp_paths', 'cwd')
if not osp.exists(cwd):
os.makedirs(cwd)
# On Windows, some modules (notably Matplotlib)
# cause exceptions if they cannot get the user home.
# So, we need to pass the USERPROFILE env variable to
# the PyLS.
if os.name == "nt" and "USERPROFILE" in os.environ:
env.insert("USERPROFILE", os.environ["USERPROFILE"])
else:
# There's no need to define a cwd for other servers.
cwd = None
# Most LSP servers spawn other processes, which may require
# some environment variables.
for var in os.environ:
env.insert(var, os.environ[var])
logger.info('Server process env variables: {0}'.format(env.keys()))
# Setup server
self.server.setProcessEnvironment(env)
self.server.errorOccurred.connect(self.handle_process_errors)
self.server.setWorkingDirectory(cwd)
self.server.setProcessChannelMode(QProcess.MergedChannels)
if self.server_log_file is not None:
self.server.setStandardOutputFile(self.server_log_file)
# Start server
self.server.start(self.server_args[0], self.server_args[1:])
def start_server(self):
"""Start server."""
# This is not necessary if we're trying to connect to an
# external server
if self.external_server:
return
# Set server log file
server_log_file = None
if get_debug_level() > 0:
# Create server log file
server_log_fname = 'server_{0}_{1}.log'.format(
self.language, os.getpid())
server_log_file = get_conf_path(
osp.join('lsp_logs', server_log_fname))
if not osp.exists(osp.dirname(server_log_file)):
os.makedirs(osp.dirname(server_log_file))
if self.stdio:
if self.language == 'python':
self.server_args += ['--log-file', server_log_file]
self.transport_args += ['--server-log-file', server_log_file]
# Start server with logging options
if self.language == 'python':
if get_debug_level() == 2:
self.server_args.append('-v')
elif get_debug_level() == 3:
self.server_args.append('-vv')
logger.info('Starting server: {0}'.format(' '.join(self.server_args)))
# Set the PyLS current working to an empty dir inside
# our config one. This avoids the server to pick up user
# files such as random.py or string.py instead of the
# standard library modules named the same.
if self.language == 'python':
cwd = get_conf_path('empty_cwd')
if not osp.exists(cwd):
os.mkdir(cwd)
else:
cwd = None
# Setup server
self.server = QProcess(self)
self.server.errorOccurred.connect(self.handle_process_errors)
self.server.setWorkingDirectory(cwd)
self.server.setProcessChannelMode(QProcess.MergedChannels)
if server_log_file is not None:
self.server.setStandardOutputFile(server_log_file)
# Start server
self.server.start(self.server_args[0], self.server_args[1:])
def create_process(self):
self.shell.clear()
self.process = QProcess(self)
self.process.setProcessChannelMode(QProcess.MergedChannels)
# PYTHONPATH (in case we use Python in this terminal, e.g. py2exe)
env = [
to_text_string(_path)
for _path in self.process.systemEnvironment()
]
processEnvironment = QProcessEnvironment()
for envItem in env:
envName, separator, envValue = envItem.partition('=')
processEnvironment.insert(envName, envValue)
add_pathlist_to_PYTHONPATH(env, self.path)
self.process.setProcessEnvironment(processEnvironment)
# Working directory
if self.wdir is not None:
self.process.setWorkingDirectory(self.wdir)
# Shell arguments
if os.name == 'nt':
p_args = ['/Q']
else:
p_args = ['-i']
if self.arguments:
p_args.extend(shell_split(self.arguments))
self.process.readyReadStandardOutput.connect(self.write_output)
self.process.finished.connect(self.finished)
self.kill_button.clicked.connect(self.process.kill)
if os.name == 'nt':
self.process.start('cmd.exe', p_args)
else:
# Using bash:
self.process.start('bash', p_args)
self.send_to_process('PS1="\\u@\\h:\\w> "\n')
running = self.process.waitForStarted()
self.set_running_state(running)
if not running:
QMessageBox.critical(self, _("Error"),
_("Process failed to start"))
else:
self.shell.setFocus()
self.started.emit()
return self.process
def start(self, config, pythonpath):
"""
Start process which will run the unit test suite.
The process is run in the working directory specified in 'config',
with the directories in `pythonpath` added to the Python path for the
test process. The test results are written to the file
`self.resultfilename`. The standard output and error are also recorded.
Once the process is finished, `self.finished()` will be called.
Parameters
----------
config : TestConfig
Unit test configuration.
pythonpath : list of str
List of directories to be added to the Python path
Raises
------
RuntimeError
If process failed to start.
"""
wdir = config.wdir
self.process = QProcess(self)
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.setWorkingDirectory(wdir)
self.process.finished.connect(self.finished)
if pythonpath is not None:
env = [
to_text_string(_pth)
for _pth in self.process.systemEnvironment()
]
add_pathlist_to_PYTHONPATH(env, pythonpath)
processEnvironment = QProcessEnvironment()
for envItem in env:
envName, separator, envValue = envItem.partition('=')
processEnvironment.insert(envName, envValue)
self.process.setProcessEnvironment(processEnvironment)
executable = get_python_executable()
p_args = ['-m', self.module] + self.create_argument_list()
try:
os.remove(self.resultfilename)
except OSError:
pass
self.process.start(executable, p_args)
running = self.process.waitForStarted()
if not running:
raise RuntimeError
def run(self):
"""Handle the connection with the server.
"""
# Set up the zmq port.
self.socket = self.context.socket(zmq.PAIR)
self.port = self.socket.bind_to_random_port('tcp://*')
# Set up the process.
self.process = QProcess(self)
if self.cwd:
self.process.setWorkingDirectory(self.cwd)
p_args = ['-u', self.target, str(self.port)]
if self.extra_args is not None:
p_args += self.extra_args
# Set up environment variables.
processEnvironment = QProcessEnvironment()
env = self.process.systemEnvironment()
if (self.env and 'PYTHONPATH' not in self.env) or self.env is None:
python_path = osp.dirname(get_module_path('spyder'))
# Add the libs to the python path.
for lib in self.libs:
try:
path = osp.dirname(imp.find_module(lib)[1])
python_path = osp.pathsep.join([python_path, path])
except ImportError:
pass
if self.extra_path:
try:
python_path = osp.pathsep.join([python_path] +
self.extra_path)
except Exception as e:
debug_print("Error when adding extra_path to plugin env")
debug_print(e)
env.append("PYTHONPATH=%s" % python_path)
if self.env:
env.update(self.env)
for envItem in env:
envName, separator, envValue = envItem.partition('=')
processEnvironment.insert(envName, envValue)
self.process.setProcessEnvironment(processEnvironment)
# Start the process and wait for started.
self.process.start(self.executable, p_args)
self.process.finished.connect(self._on_finished)
running = self.process.waitForStarted()
if not running:
raise IOError('Could not start %s' % self)
# Set up the socket notifer.
fid = self.socket.getsockopt(zmq.FD)
self.notifier = QSocketNotifier(fid, QSocketNotifier.Read, self)
self.notifier.activated.connect(self._on_msg_received)
def start_process(self, process, args=None, cwd=None, env=None):
"""
Starts a process interactively.
:param process: Process to run
:type process: str
:param args: List of arguments (list of str)
:type args: list
:param cwd: Working directory
:type cwd: str
:param env: environment variables (dict).
"""
self.setReadOnly(False)
if env is None:
env = {}
if args is None:
args = []
if not self._running:
self.process = QProcess()
self.process.finished.connect(self._on_process_finished)
self.process.started.connect(self.process_started.emit)
self.process.error.connect(self._write_error)
self.process.readyReadStandardError.connect(self._on_stderr)
self.process.readyReadStandardOutput.connect(self._on_stdout)
if cwd:
self.process.setWorkingDirectory(cwd)
e = self.process.systemEnvironment()
ev = QProcessEnvironment()
for v in e:
values = v.split('=')
ev.insert(values[0], '='.join(values[1:]))
for k, v in env.items():
ev.insert(k, v)
self.process.setProcessEnvironment(ev)
self._running = True
self._process_name = process
self._args = args
if self._clear_on_start:
self.clear()
self._user_stop = False
self._write_started()
self.process.start(process, args)
self.process.waitForStarted()
else:
_logger().warning('a process is already running')
def start(self):
"""Start the code analysis."""
filename = str(self.filecombo.currentText())
self.process = QProcess(self)
self.process.setProcessChannelMode(QProcess.SeparateChannels)
self.process.setWorkingDirectory(getcwd_or_home())
self.process.readyReadStandardOutput.connect(self.read_output)
self.process.readyReadStandardError.connect(
lambda: self.read_output(error=True))
self.process.finished.connect(
lambda ec, es=QProcess.ExitStatus: self.finished(ec, es))
self.stop_button.clicked.connect(self.process.kill)
self.output = ''
self.error_output = ''
plver = PYLINT_VER
if plver is not None:
p_args = ['-m', 'pylint', '--output-format=text']
if plver.split('.')[0] == '0':
p_args += ['-i', 'yes']
else:
# Option '-i' (alias for '--include-ids') was removed in pylint
# 1.0
p_args += [
"--msg-template='{msg_id}:{line:3d},"
"{column}: {obj}: {msg}"
]
pylintrc_path = self.get_pylintrc_path(filename=filename)
if pylintrc_path is not None:
p_args += ['--rcfile={}'.format(pylintrc_path)]
p_args += [filename]
processEnvironment = QProcessEnvironment()
processEnvironment.insert("PYTHONIOENCODING", "utf8")
self.process.setProcessEnvironment(processEnvironment)
self.process.start(sys.executable, p_args)
running = self.process.waitForStarted()
self.set_running_state(running)
if not running:
QMessageBox.critical(self, _("Error"),
_("Process failed to start"))
def start_server(self):
"""Start server."""
# This is not necessary if we're trying to connect to an
# external server
if self.external_server or self.stdio:
return
logger.info('Starting server: {0}'.format(' '.join(self.server_args)))
# Create server process
self.server = QProcess(self)
env = self.server.processEnvironment()
if DEV:
# Use local pyls instead of site-packages one
env.insert('PYTHONPATH', os.pathsep.join(sys.path)[:])
# Adjustments for the Python language server.
if self.language == 'python':
# Set the PyLS current working to an empty dir inside
# our config one. This avoids the server to pick up user
# files such as random.py or string.py instead of the
# standard library modules named the same.
cwd = osp.join(get_conf_path(), 'lsp_paths', 'cwd')
if not osp.exists(cwd):
os.makedirs(cwd)
else:
# There's no need to define a cwd for other servers.
cwd = None
# Most LSP servers spawn other processes, which may require
# some environment variables.
for var in os.environ:
env.insert(var, os.environ[var])
logger.info('Server process env variables: {0}'.format(env.keys()))
# Setup server
self.server.setProcessEnvironment(env)
self.server.errorOccurred.connect(self.handle_process_errors)
self.server.setWorkingDirectory(cwd)
self.server.setProcessChannelMode(QProcess.MergedChannels)
if self.server_log_file is not None:
self.server.setStandardOutputFile(self.server_log_file)
# Start server
self.server.start(self.server_args[0], self.server_args[1:])
def _prepare_process(self, config, pythonpath):
"""
Prepare and return process for running the unit test suite.
This sets the working directory and environment.
"""
process = QProcess(self)
process.setProcessChannelMode(QProcess.MergedChannels)
process.setWorkingDirectory(config.wdir)
process.finished.connect(self.finished)
if pythonpath:
env = QProcessEnvironment.systemEnvironment()
old_python_path = env.value('PYTHONPATH', None)
python_path_str = os.pathsep.join(pythonpath)
if old_python_path:
python_path_str += os.pathsep + old_python_path
env.insert('PYTHONPATH', python_path_str)
process.setProcessEnvironment(env)
return process
def start_transport(self):
"""Start transport layer."""
logger.info('Starting transport for {1}: {0}'.format(
' '.join(self.transport_args), self.language))
# Create transport process
self.transport = QProcess(self)
env = self.transport.processEnvironment()
# Most LSP servers spawn other processes other than Python, which may
# require some environment variables
if self.language != 'python' and self.stdio:
for var in os.environ:
env.insert(var, os.environ[var])
logger.info('Transport process env variables: {0}'.format(
env.keys()))
self.transport.setProcessEnvironment(env)
# Modifying PYTHONPATH to run transport in development mode or
# tests
if (DEV or running_under_pytest()) and not running_in_ci():
sys_path = self._clean_sys_path()
if running_under_pytest():
env.insert('PYTHONPATH', os.pathsep.join(sys_path)[:])
else:
env.insert('PYTHONPATH', os.pathsep.join(sys_path)[1:])
self.transport.setProcessEnvironment(env)
# Set up transport
self.transport.errorOccurred.connect(self.handle_process_errors)
if self.stdio:
self.transport.setProcessChannelMode(QProcess.SeparateChannels)
if self.transport_log_file is not None:
self.transport.setStandardErrorFile(self.transport_log_file)
else:
self.transport.setProcessChannelMode(QProcess.MergedChannels)
if self.transport_log_file is not None:
self.transport.setStandardOutputFile(self.transport_log_file)
# Start transport
self.transport.start(self.transport_args[0], self.transport_args[1:])
def start_transport(self):
"""Start transport layer."""
self.transport_args = list(map(str, self.transport_args))
logger.info('Starting transport: {0}'.format(' '.join(
self.transport_args)))
self.transport = QProcess(self)
self.transport.errorOccurred.connect(self.handle_process_errors)
# Modifying PYTHONPATH to run transport in development mode or
# tests
if DEV or running_under_pytest():
env = QProcessEnvironment()
if running_under_pytest():
env.insert('PYTHONPATH', os.pathsep.join(sys.path)[:])
else:
env.insert('PYTHONPATH', os.pathsep.join(sys.path)[1:])
self.transport.setProcessEnvironment(env)
# Set transport log file
transport_log_file = None
if get_debug_level() > 0:
transport_log_fname = 'transport_{0}_{1}.log'.format(
self.language, os.getpid())
transport_log_file = get_conf_path(
osp.join('lsp_logs', transport_log_fname))
if not osp.exists(osp.dirname(transport_log_file)):
os.makedirs(osp.dirname(transport_log_file))
# Set channel properties
if self.stdio:
self.transport_args += self.server_args
self.transport.setProcessChannelMode(QProcess.SeparateChannels)
if transport_log_file is not None:
self.transport.setStandardErrorFile(transport_log_file)
else:
self.transport.setProcessChannelMode(QProcess.MergedChannels)
if transport_log_file is not None:
self.transport.setStandardOutputFile(transport_log_file)
# Start transport
self.transport.start(self.transport_args[0], self.transport_args[1:])
def __init__(self, output_widget: QTextEdit = None):
from ...plugins import plugin_manager
# create install process
self._output_widget = None
self.process = QProcess()
self.process.setProgram(sys.executable)
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.readyReadStandardOutput.connect(self._on_stdout_ready)
# setup process path
env = QProcessEnvironment()
combined_paths = os.pathsep.join([
user_site_packages(),
env.systemEnvironment().value("PYTHONPATH")
])
env.insert("PYTHONPATH", combined_paths)
self.process.setProcessEnvironment(env)
self.process.finished.connect(lambda: plugin_manager.discover())
self.process.finished.connect(lambda: plugin_manager.prune())
self.set_output_widget(output_widget)
def run_command(self, command_list):
for qwidget in self.qwidgets_to_disable:
qwidget.setEnabled(False)
self._busy.setRange(0, 0)
self._busy.setVisible(True)
self._busy.update()
self._timer_label.setVisible(True)
self._time0 = time.time()
self.process = QProcess(self)
self.process.readyReadStandardOutput.connect(self.stdout_ready)
self.process.finished.connect(self.on_finished)
#self.process.started.connect(lambda: print_func('Started!'))
#self.process.finished.connect(lambda: print_func('Finished!'))
#self.process.startDetached(command_list[0], command_list[1:])
self.process.start(command_list[0], command_list[1:])
for qwidget in self.qwidgets_to_disable:
qwidget.setEnabled(True)
def __init__(self,
cmd_list,
parse=False,
pip=False,
callback=None,
extra_kwargs=None):
"""Conda worker based on a QProcess for non blocking UI.
Parameters
----------
cmd_list : list of str
Command line arguments to execute.
parse : bool (optional)
Parse json from output.
pip : bool (optional)
Define as a pip command.
callback : func (optional)
If the process has a callback to process output from comd_list.
extra_kwargs : dict
Arguments for the callback.
"""
super(ProcessWorker, self).__init__()
self._result = None
self._cmd_list = cmd_list
self._parse = parse
self._pip = pip
self._conda = not pip
self._callback = callback
self._fired = False
self._communicate_first = False
self._partial_stdout = None
self._extra_kwargs = extra_kwargs if extra_kwargs else {}
self._timer = QTimer()
self._process = QProcess()
self._timer.setInterval(150)
self._timer.timeout.connect(self._communicate)
# self._process.finished.connect(self._communicate)
self._process.readyReadStandardOutput.connect(self._partial)
def __init__(self, parent=None, window_flags=None):
super(PyChopGui, self).__init__(parent)
if window_flags:
self.setWindowFlags(window_flags)
self.folder = os.path.dirname(sys.modules[self.__module__].__file__)
for fname in os.listdir(self.folder):
if fname.endswith('.yaml'):
instobj = Instrument(os.path.join(self.folder, fname))
self.instruments[instobj.name] = instobj
self.choppers[instobj.name] = instobj.getChopperNames()
self.minE[instobj.name] = max([instobj.emin, 0.01])
self.maxE[instobj.name] = instobj.emax
self.drawLayout()
self.setInstrument(list(self.instruments.keys())[0])
self.resaxes_xlim = 0
self.qeaxes_xlim = 0
self.isFramePlotted = 0
# help
self.assistant_process = QProcess(self)
# pylint: disable=protected-access
self.mantidplot_name = 'PyChop'
def launch(project_path, command):
"""
Handle launching commands from projects.
"""
logger.debug(str((project_path, command)))
command = command.format(PREFIX=project_path)
command = command.replace('\\', '/')
if os.name == 'nt':
command = command.replace('/bin', '/Scripts')
if '.ipynb' in command:
filename = command.replace('ipython notebook ', '')
filename = filename.replace('jupyter notebook ', '')
run_notebook(project_path=project_path, filename=filename)
elif command.startswith('python '):
filename = command.replace('python ', '')
run_python_file(project_path, filename=filename)
else:
proc = QProcess()
logger.debug(command)
proc.startDetached(command)
