To continuously fetch data and update the display in real-time, you can use a separate thread to fetch the data and emit a signal every time new data is available. The main thread can then connect a slot to this signal to update the UI. Here’s a simplified example:

class DataThread(QThread):
    data_signal = pyqtSignal(object)

    def run(self):
        while True:
            data = self.fetch_data()  # replace with your data fetching logic
            self.data_signal.emit(data)
            time.sleep(1)  # sleep for a while to prevent high CPU usage

class ATE_UI(QDialog):
    def __init__(self):
        super(ATE_UI,self).__init__()
        loadUi('ATE_Update.ui',self)
        
        self.Reports_Table.setColumnWidth(0,250)
        
        self.label_4.setText('Flight Mode: VTOL')
        
        timer=QTimer(self)
        timer.timeout.connect(self.showTime)
        timer.start(1)
        self.Test_Button.clicked.connect(self.start_fetching_data)
        self.Save_Button.clicked.connect(self.save_data)

        self.data_thread = DataThread()
        self.data_thread.data_signal.connect(self.update_display)

    def start_fetching_data(self):
        self.data_thread.start()

    def update_display(self, data):
        # update your display with the new data here
        pass

    # ... rest of your code ...

In this example, pressing the Test_Button will start the DataThread, which fetches data in a loop until stopped. Every time new data is fetched, it emits a signal with the data, which is connected to the update_display slot in the main thread. This slot can then update the UI with the new data.

Please replace self.fetch_data() with your actual data fetching logic and implement the update_display method to update your UI with the new data. Also, don’t forget to handle stopping the thread when necessary. You might want to add a stop button and connect it to a method that calls self.data_thread.terminate(). Be aware that terminating threads can be dangerous if not handled properly, so it’s better to have a mechanism in your thread to stop it gracefully. For example, you can use a QMutex and a flag to check whether the thread should stop or continue fetching data. If the flag is set, the thread can finish its current iteration and then stop itself by returning from the run method. This way, you can avoid abruptly stopping the thread and potentially leaving resources in an inconsistent state.

Please note that this is a simplified example and might not cover all edge cases. Always make sure to handle exceptions and edge cases in your code to prevent crashes and ensure a smooth user experience. Also, keep in mind that updating the UI from a different thread is not safe, and you should always use signals and slots for communication between threads in Qt.

    def stop_worker():
        with mutex:
            worker.stop_flag = True

    # Connect the worker's finished signal to stop the worker
    worker.finished.connect(stop_worker)

because I tried but it was not working. It prompt to force close the UI.
@J-Hilk

import sys
import time
from PyQt5.QtCore import Qt, QThread, QTimer, QObject, QMutex, pyqtSignal
from PyQt5.QtWidgets import QApplication, QLabel, QMainWindow, QPushButton, QVBoxLayout, QWidget

class Worker(QObject):
    finished = pyqtSignal()

    def __init__(self, mutex):
        super().__init__()
        self.mutex = mutex
        self.stop_flag = False

    def run_long_task(self):
        while not self.stop_flag:
            # Simulate some work
            time.sleep(1)
            print("Worker thread: Doing some work...")

        self.finished.emit()

class Window(QMainWindow):
    def __init__(self):
        super().__init__()
        self.clicksCount = 0
        self.setup_ui()

    def setup_ui(self):
        self.setWindowTitle("Thread Example")
        self.resize(300, 150)
        self.centralWidget = QWidget()
        self.setCentralWidget(self.centralWidget)

        # Create widgets
        self.clicksLabel = QLabel("Counting: 0 clicks", self)
        self.clicksLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
        self.countBtn = QPushButton("Click me!", self)
        self.countBtn.clicked.connect(self.count_clicks)
        self.longRunningBtn = QPushButton("Long-Running Task!", self)
        self.longRunningBtn.clicked.connect(self.run_long_task)

        # Set layout
        layout = QVBoxLayout()
        layout.addWidget(self.clicksLabel)
        layout.addWidget(self.countBtn)
        layout.addStretch()
        layout.addWidget(self.longRunningBtn)
        self.centralWidget.setLayout(layout)

    def count_clicks(self):
        self.clicksCount += 1
        self.clicksLabel.setText(f"Counting: {self.clicksCount} clicks")

    def run_long_task(self):
        mutex = QMutex()
        worker = Worker(mutex)

        def stop_worker():
            with mutex:
                worker.stop_flag = True

        # Connect the worker's finished signal to stop the worker
        worker.finished.connect(stop_worker)

        # Start the worker thread
        thread = QThread()
        worker.moveToThread(thread)
        thread.started.connect(worker.run_long_task)
        thread.start()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    win = Window()
    win.show()
    sys.exit(app.exec_())

Let me ask the AI to whip up an example.

Or I need to do something else?

Can I have more than 1 worker class inherited from Q Thread?

Sure, each of the worker runs then in its own thread.
"And How can I achieve that?" - in the same way you create one worker.

To continuously fetch data and update the display in real-time, you can use a separate thread to fetch the data and emit a signal every time new data is available. The main thread can then connect a slot to this signal to update the UI. Here’s a simplified example:

class DataThread(QThread):
    data_signal = pyqtSignal(object)

    def run(self):
        while True:
            data = self.fetch_data()  # replace with your data fetching logic
            self.data_signal.emit(data)
            time.sleep(1)  # sleep for a while to prevent high CPU usage

class ATE_UI(QDialog):
    def __init__(self):
        super(ATE_UI,self).__init__()
        loadUi('ATE_Update.ui',self)
        
        self.Reports_Table.setColumnWidth(0,250)
        
        self.label_4.setText('Flight Mode: VTOL')
        
        timer=QTimer(self)
        timer.timeout.connect(self.showTime)
        timer.start(1)
        self.Test_Button.clicked.connect(self.start_fetching_data)
        self.Save_Button.clicked.connect(self.save_data)

        self.data_thread = DataThread()
        self.data_thread.data_signal.connect(self.update_display)

    def start_fetching_data(self):
        self.data_thread.start()

    def update_display(self, data):
        # update your display with the new data here
        pass

    # ... rest of your code ...

In this example, pressing the Test_Button will start the DataThread, which fetches data in a loop until stopped. Every time new data is fetched, it emits a signal with the data, which is connected to the update_display slot in the main thread. This slot can then update the UI with the new data.

Please replace self.fetch_data() with your actual data fetching logic and implement the update_display method to update your UI with the new data. Also, don’t forget to handle stopping the thread when necessary. You might want to add a stop button and connect it to a method that calls self.data_thread.terminate(). Be aware that terminating threads can be dangerous if not handled properly, so it’s better to have a mechanism in your thread to stop it gracefully. For example, you can use a QMutex and a flag to check whether the thread should stop or continue fetching data. If the flag is set, the thread can finish its current iteration and then stop itself by returning from the run method. This way, you can avoid abruptly stopping the thread and potentially leaving resources in an inconsistent state.

Please note that this is a simplified example and might not cover all edge cases. Always make sure to handle exceptions and edge cases in your code to prevent crashes and ensure a smooth user experience. Also, keep in mind that updating the UI from a different thread is not safe, and you should always use signals and slots for communication between threads in Qt.

How can I continuously fetch data and display it at the same time?

I have no idea how you fetch the data - you did not explain what camera and how you're accessing it. And regarding displaying: I already wrote that you can pass the data from the camera fetching thread to the UI thread using signals/slots.

import os, sys, time
from PyQt5 import QtWidgets, QtCore
from PyQt5.QtCore import QLibraryInfo, pyqtSignal, pyqtSlot, QUrl, QTimer, QTime, QDate, QThread
from PyQt5.QtWidgets import QDialog, QApplication, QMainWindow
from PyQt5.uic import loadUi
from PyQt5.QtGui import QImage
from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent

os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = QLibraryInfo.location(
QLibraryInfo.PluginsPath
)

class Sample_UI(QDialog):
def init(self):
super(Sample_UI,self).init()
loadUi('Sample_Update.ui',self)

    self.Reports_Table.setColumnWidth(0,250)
    
    self.label_4.setText('LOGIC_CONTROL')
    
    timer=QTimer(self)
    timer.timeout.connect(self.showTime)
    timer.start(1)
    self.Test_Button.clicked.connect(self.testing)
    self.Save_Button.clicked.connect(self.save_data)

def logic(self):
import logic_build_library
self.abc=logic_build_library.class1()

    try:
        systat=self.abc.sys_status()
        if systat is not None:
            self.label_12.setStyleSheet('background-color: green; color: black;')
        else:
            self.label_12.setStyleSheet('background-color: red; color: black;')
    except Exception as e:
        self.label_12.setStyleSheet('background-color: red; color: black;')
def showTime(self):
    currentTime = QTime.currentTime()
    today_date=QDate.currentDate()
    displayTxt = today_date.toString()+" "+currentTime.toString('hh:mm:ss')
    self.label_6.setText(displayTxt)
def save_data(self):
    print('Data Saved!')
    login=Login()
    widget.setFixedWidth(360)
    widget.setFixedHeight(360)
    widget.addWidget(login)
    widget.setCurrentIndex(widget.currentIndex()+1)

How can I continuously fetch data and display it at the same time?