Das deutsche Python-Forum

Code: Alles auswählen

import sys
from PyQt5.QtWidgets import (
	QApplication
)
from PyQt5.QtCore import (
	QProcess
)


class OpenApplication(object):

	def __init__(self, cmd=None, args=[]):
		super().__init__()

		self.p = None
		if not cmd or args == []:
			return
		self.start_process(cmd, args)
		sys.exit()

	def start_process(self, cmd, args):
		self.p = QProcess()
		self.p.readyReadStandardOutput.connect(self.handle_stdout)
		self.p.readyReadStandardError.connect(self.handle_stderr)
		self.p.stateChanged.connect(self.handle_state)
		self.p.finished.connect(self.process_finished)
		self.p.setProgram(cmd)
		self.p.setArguments(args)
		self.p.start()
		self.p.waitForStarted()
		self.p.waitForFinished()

	def handle_stderr(self):
		data = self.p.readAllStandardError()
		stderr = bytes(data).decode("utf8")

	def handle_stdout(self):
		data = self.p.readAllStandardOutput()
		stdout = bytes(data).decode("utf8")

	def handle_state(self, state):
		states = {
			QProcess.NotRunning: 'Not running',
			QProcess.Starting: 'Starting',
			QProcess.Running: 'Running',
		}
		state_name = states[state]
		print(f"State changed: {state_name}")

	def process_finished(self, exitCode, exitStatus):
		print(f'process finished: {exitCode}, {exitStatus}')
		self.p = None


def main(cmd=None, args=[]):
	app = QApplication(sys.argv)
	w = OpenApplication(cmd, args=args)
	app.exec_()

	filepath = '/path to/my_program.py'
	main(cmd='python3.12', args=[filepath])

Code: Alles auswählen

State changed: Starting
State changed: Running
State changed: Not running
process finished: 0, 0

Code: Alles auswählen

State changed: Starting
State changed: Running
QProcess: Destroyed while process ("python3.12") is still running.

Code: Alles auswählen

import os
import sys
import signal
from PyQt5.QtWidgets import (
	QApplication
)
from PyQt5.QtCore import (
	QProcess
)


class OpenApplication(object):

	def __init__(self, cmd=None, args=[]):
		super().__init__()

		self.p = None
		if not cmd or args == []:
			return
		self.start_process(cmd, args)
		if self.p:
			os.kill(self.pid, signal.SIGINT)
			self.p.kill()

	def start_process(self, cmd, args):
		self.p = QProcess()
		self.p.readyReadStandardOutput.connect(self.handle_stdout)
		self.p.readyReadStandardError.connect(self.handle_stderr)
		self.p.stateChanged.connect(self.handle_state)
		self.p.finished.connect(self.process_finished)
		self.p.setProgram(cmd)
		self.p.setArguments(args)
		self.p.start()
		self.pid = self.p.processId()
		self.p.waitForStarted()
		self.p.waitForFinished()

	def handle_stderr(self):
		data = self.p.readAllStandardError()
		stderr = bytes(data).decode("utf8")

	def handle_stdout(self):
		data = self.p.readAllStandardOutput()
		stdout = bytes(data).decode("utf8")

	def handle_state(self, state):
		states = {
			QProcess.NotRunning: 'Not running',
			QProcess.Starting: 'Starting',
			QProcess.Running: 'Running',
		}
		state_name = states[state]
		print(f"State changed: {state_name}")

	def process_finished(self, exitCode, exitStatus):
		print(f'process finished: {exitCode}, {exitStatus}')
		self.p = None
		return


def main(cmd=None, args=[]):
	app = QApplication(sys.argv)
	w = OpenApplication(cmd, args=args)
	app.exec_()

if __name__ == '__main__':
	filepath = '/path to/my_proc.py'
	main(cmd='python3.12', args=[filepath])

Code: Alles auswählen

State changed: Starting
State changed: Running
State changed: Not running
process finished: 9, 1

Code: Alles auswählen

import sys
from pathlib import Path

from PyQt5.QtCore import QCoreApplication, QProcess

STATE_TO_TEXT = {
    QProcess.NotRunning: "Not running",
    QProcess.Starting: "Starting",
    QProcess.Running: "Running",
}


def drain(method):
    _text = bytes(method()).decode("utf-8")


def on_finished(exit_code, exit_status):
    print(f"process finished: {exit_code}, {exit_status}")
    QCoreApplication.instance().quit()


def main(command, arguments=None):
    app = QCoreApplication(sys.argv)
    process = QProcess()
    process.readyReadStandardOutput.connect(
        lambda: drain(process.readAllStandardOutput)
    )
    process.readyReadStandardError.connect(
        lambda: drain(process.readAllStandardError)
    )
    process.stateChanged.connect(
        lambda state: print(f"State changed: {STATE_TO_TEXT[state]}")
    )
    process.finished.connect(on_finished)
    process.start(command, [] if arguments is None else arguments)
    app.exec_()


if __name__ == "__main__":
    main(sys.executable, [str(Path(__file__).parent / "external.py")])

Code: Alles auswählen

import sys
import time
import threading
import subprocess
from pathlib import Path
from PyQt5.QtWidgets import (
	QApplication
	)


def executeObjects(modulpath=[]):
	threads = [threading.Thread(target=run_script, args=(path,))
		for path in modulpath]
	[(thread.start(), time.sleep(1)) for thread in threads]
	[thread.join() for thread in threads]

def run_script(script_name):
	subprocess.run([sys.executable, script_name])

def openObject(modulpath=[]):
	main(modulpath=modulpath)


# file and base path
filePath = str(Path(__file__).parent)
basePath = str(Path(filePath).parent)
# main test
filepath = f'{basePath}/Woding/Woding.py'
filepath1 = f'{basePath}/Calendar/Calendar.py'
modulpath = [filepath, filepath1]
def main():
	App = QApplication(sys.argv)
	obj = executeObjects(modulpath=modulpath)
	sys.exit(App.exec())

if __name__ == '__main__':
	main()

Code: Alles auswählen

import os
import sys
import platform
from pathlib import Path
from PyQt5.QtWidgets import (
	QApplication
	)

# update sys path
filePath = str(Path(__file__).parent)
basePath = str(Path(filePath).parent)
try:
	from sysUpdate import sysUpdate
except ModuleNotFoundError:
	sys.path.append(basePath)
	from sysUpdate import sysUpdate
sysUpdate(__file__)


def executeModul(modulpath=[]):
	if modulpath == __file__ or modulpath == [__file__]:
		return
	# open first application
	# wait until the previous application has finished,
	# then start the next application
	[os.system(f'{sys.executable} {path}')
		for path in modulpath if os.path.isdir(os.path.dirname(path))]


# file and base path
filePath = str(Path(__file__).parent)
basePath = str(Path(filePath).parent)
# main test
filepath = f'{basePath}/Woding/Woding.py'
filepath1 = f'{basePath}/Calendar/Calendar.py'
modulpath = [filepath, filepath1]
def main():
	App = QApplication(sys.argv)
	obj = executeModul(modulpath=modulpath)
	sys.exit(App.exec())

if __name__ == '__main__':
	main()

Code: Alles auswählen

import sys
import time
import threading
import subprocess
from pathlib import Path

BASE_PATH = Path(__file__).parent.parent
MODULE_PATHS = [
    BASE_PATH / "Woding" / "Woding.py",
    BASE_PATH / "Calendar" / "Calendar.py",
]

def execute_objects(modulpaths):
    threads = [threading.Thread(target=run_script, args=(path,)) for path in modulpaths]
    for thread in threads:
        thread.start()
        time.sleep(1)
    for thread in threads:
        thread.join()


def run_script(script_name):
    subprocess.run([sys.executable, script_name])

def main():
    execute_objects(modulpath=MODULE_PATHS)


if __name__ == "__main__":
    main()

Code: Alles auswählen

import sys
import subprocess
from pathlib import Path

BASE_PATH = Path(__file__).parent.parent
MODULE_PATHS = [
    BASE_PATH / "Woding" / "Woding.py",
    BASE_PATH / "Calendar" / "Calendar.py",
]


def execute_objects(modulpaths):
    processes = [
        subprocess.Popen([sys.executable, script_name])
        for script_name in modulpaths
    ]
    for process in processes:
        process.wait()


def main():
    execute_objects(modulpath=MODULE_PATHS)


if __name__ == "__main__":
    main()

Code: Alles auswählen

import sys
import time
import subprocess
from pathlib import Path

BASE_PATH = Path(__file__).parent.parent
MODULE_PATHS = [
    BASE_PATH / "Woding" / "Woding.py",
    BASE_PATH / "Calendar" / "Calendar.py",
]


def execute_objects(modulpaths=[]):
    processes = [
        (time.sleep(1), subprocess.Popen([sys.executable, script_name]))
        for script_name in modulpaths
       ]


def main():
    execute_objects(modulpaths=MODULE_PATHS)


if __name__ == "__main__":
    main()

Code: Alles auswählen

import sys
import subprocess
import time
from pathlib import Path

BASE_PATH = Path(__file__).parent.parent
MODULE_PATHS = [
    BASE_PATH / "Woding" / "Woding.py",
    BASE_PATH / "Calendar" / "Calendar.py",
]


def execute_objects(modulpaths):
    processes = []
    for script_name in modulpaths:
        processes.append(subprocess.Popen([sys.executable, script_name]))
        time.sleep(1)
    for process in processes:
        process.wait()


def main():
    execute_objects(modulpath=MODULE_PATHS)


if __name__ == "__main__":
    main()