How to pass values (data) between python scripts?

In general Qt is not process-safe so you should not update the GUI from another process. An alternative is to create a QThread (or threading.Thread) that only parses the information of the Queue and emits a signal with the information to update the GUI. Another option is to use a QTimer that does the above: monitor the Queue.

class Worker(QObject):
    messageChanged = Signal(str)

def monitoring(p, worker):
    while True:
        try:
            msg = p.recv()
        except EOFError:
            break
        else:
            worker.messageChanged.emit(msg)

r, w = Pipe(duplex=False)
p = Process(target=foo, args=(w,))

worker = Worker()
worker.messageChanged.connect(self.some_slot)

threading.Thread(target=monitoring, args=(r, worker), daemon=True).start()
p.start()

But using multiprocessing can add unnecessary complexity, instead you can use qasync(python -m pip install qasync) and then use asyncio:

import asyncio
from functools import cached_property
import sys

import discord
from PySide6 import QtCore, QtWidgets
from qasync import QEventLoop, asyncSlot


class DiscordManager(QtCore.QObject):
    connected = QtCore.Signal()
    disconnected = QtCore.Signal()
    messageChanged = QtCore.Signal(discord.message.Message)

    def __init__(self, parent=None):
        super().__init__(parent)
        self.client.event(self.on_message)
        self.client.event(self.on_connect)
        self.client.event(self.on_disconnect)

    @cached_property
    def client(self):
        return discord.Client()

    async def on_message(self, message):
        self.messageChanged.emit(message)

    async def start(self):
        await self.client.start(
            "<TOKEN>"
        )

    async def close(self):
        await self.client.close()

    async def on_connect(self):
        self.connected.emit()

    async def on_disconnect(self):
        self.disconnected.emit()


class MainWindow(QtWidgets.QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.button = QtWidgets.QPushButton("Start")
        self.label = QtWidgets.QLabel(alignment=QtCore.Qt.AlignCenter)

        central_widget = QtWidgets.QWidget()
        lay = QtWidgets.QVBoxLayout(central_widget)
        lay.addWidget(self.button)
        lay.addWidget(self.label)
        self.setCentralWidget(central_widget)

        self.button.clicked.connect(self.handle_clicked)

        self.manager.connected.connect(self.handle_connected)
        self.manager.disconnected.connect(self.handle_disconnected)
        self.manager.messageChanged.connect(self.handle_message)

    @cached_property
    def manager(self):
        return DiscordManager()

    @asyncSlot()
    async def handle_clicked(self):
        if self.button.text() == "Start":
            await self.manager.start()
        else:
            await self.manager.close()

    def handle_message(self, message):
        self.label.setText(message.content)

    def handle_connected(self):
        self.button.setText("Stop")

    def handle_disconnected(self):
        self.button.setText("Start")


def main():
    app = QtWidgets.QApplication(sys.argv)
    loop = QEventLoop(app)
    asyncio.set_event_loop(loop)
    w = MainWindow()
    w.show()
    loop.run_forever()


if __name__ == "__main__":
    main()