Multi Thread and queue initialisation with Pygubu

[Mike-152]

Hello Alejandro,

Being totally seduced by the quality and benefits of Pygubu-designer, I started an application which, from gedcom files, imports genealogical data into a database.
The import obviously takes a long time.
I therefore set up a second thread inspired by your tutorial which deals with this subject.
The daughter thread works perfectly, but I have a problem with the 'Queue' part which allows dialogue between the two threads...
In fact it is the initialization of the .bind which poses a problem (error received: 'GedcomUtil' object has no attribute 'bind')
The beginning of my code is reproduced below.
We are not in the tkinter context, like in your tutorial, but in a Pygubu context...
Being still far from mastering all the subtleties of python, I ask myself the following questions:

1. should the initialization of the queue be done there?
2. what does the .bind in question depend on?

Thank you for your attention.
Michel

import pygubu
import pathlib
import mysql.connector
from a_propos import APropos
from datetime import datetime
from threading import Thread
from queue import Queue
from enum import Enum, auto

PROJECT_PATH = pathlib.Path(file).parent
PROJECT_UI = PROJECT_PATH / "gedcom-util.ui"

class TicketPurpose(Enum):
    UPDATE_PROGRESS_TEXT = auto()

class Ticket:
    def init(self,
                 ticket_type: TicketPurpose,
                 ticket_value: str):
        self.ticket_type = ticket_type
        self.ticket_value = ticket_value

class GedcomUtil():
    def init(self, master=None):
        self.builder = builder = pygubu.Builder()
        builder.add_resource_path(PROJECT_PATH)
        builder.add_from_file(PROJECT_UI)
        # Main widget
        self.mainwindow = builder.get_object("toplevel1", master)
        # Main menu
        _main_menu = builder.get_object("menu1", self.mainwindow)
        self.mainwindow.configure(menu=_main_menu)
        self.est_bdd_dft = False
        builder.import_variables(self, ['est_bdd_dft'])
        builder.connect_callbacks(self)

        # to communicate with the 2° Thread
        self.queue_msg = Queue()
        self.bind("<>", self.check_queue)

…

if name == "main":

    app = GedcomUtil()
    app.run()

[jrezai]

Hi @Mike-152

Your line which has self.bind("<>", self.check_queue) should actually have a name to a self-defined virtual event, and it should use a tkinter widget to create the event, for example (notice self.mainwindow below):
self.mainwindow.bind("<<CheckQueue>>", self.check_queue)
Then create a method named check_queue

Also, just a side note: Alejandro made Pygubu Designer, while I just made some tutorials for it on YouTube.

[Mike-152]

Thank you Jobin (sorry for the confusion ;-)

[alejandroautalan]

Hello @Mike-152 thanks for trying pygubu, and sorry for the late response.

I therefore set up a second thread inspired by your tutorial which deals with this subject.

Wich tutorial are you referring to? Are you are referring to dialog example 3?

Being still far from mastering all the subtleties of python, I ask myself the following questions:
should the initialization of the queue be done there?

Yes is correct, but remember that the task needs access to this queue also.

what does the .bind in question depend on?

The @jrezai response here is valid.
Tkinter widgets have a .bind method used to connect our functions to tk events.
Please specify wich turorial are you following.

Regards.
Alejandro A.

[alejandroautalan]

@Mike-152 If you are following dialog demo 3, here is a more simplified example.
Let me know if this helps you.

demo227app.py

#!/usr/bin/python3
import pathlib
import threading
import time
import random
import queue

import pygubu

PROJECT_PATH = pathlib.Path(__file__).parent
PROJECT_UI = PROJECT_PATH / "demo227.ui"


class BackgroundTask(threading.Thread):
    def __init__(self, queue):
        super().__init__()
        self.queue = queue
        self._rows = 50

    def run(self):
        """
        DO your thread safe coding here
        """
        error_count = 0
        valid_count = 0
        processed = 0

        self.notify_status("task_start")
        for r in range(0, self._rows):
            duration = random.random()
            time.sleep(duration)
            process_ok = bool(random.getrandbits(1))
            if process_ok:
                valid_count += 1
            else:
                error_count += 1
            processed += 1
            self.notify_status(
                "task_progress",
                processed=processed,
                valid=valid_count,
                error=error_count,
            )
        self.notify_status("task_end")

    def notify_status(self, cmd, **kw):
        msg = {"message": cmd}
        msg.update(kw)
        self.queue.put(msg)


class Demo227App:
    def __init__(self, master=None):
        self.builder = builder = pygubu.Builder()
        builder.add_resource_path(PROJECT_PATH)
        builder.add_from_file(PROJECT_UI)
        # Main widget
        self.mainwindow = builder.get_object("toplevel1", master)
        self.btn_start = builder.get_object("btn_start")

        self.var_valid = None
        self.var_processed = None
        self.var_errors = None
        builder.import_variables(
            self, ["var_processed", "var_errors", "var_valid"]
        )

        builder.connect_callbacks(self)

        self.mainwindow.protocol("WM_DELETE_WINDOW", self.on_close_window)
        self.queue = queue.Queue()
        self.task = None
        # Start queue processing, even if there are no tasks running.
        # You can change this with your own logic.
        self.check_queue()

    def run(self):
        self.mainwindow.mainloop()

    def on_close_window(self, event=None):
        can_close = True
        if self.task is not None:
            print("Sorry can't close until task is complete")
            can_close = False
        if can_close:
            self.mainwindow.destroy()

    def check_queue(self):
        """Schedule queue processing."""
        self.mainwindow.after(100, self.do_process_queue)

    def do_process_queue(self):
        """Queue processing
        Process messages from BackgroundTask.
        """
        try:
            while 1:
                data = self.queue.get_nowait()
                self.process_task_message(data)
                # Update the UI
                self.mainwindow.update()
        except queue.Empty:
            pass
        self.mainwindow.after(100, self.do_process_queue)

    def process_task_message(self, data: dict):
        """PROCESS YOUR THREAD COMMANDS HERE"""
        cmd = data["message"]
        if cmd == "task_start":
            # print(cmd, self.task)
            self.var_processed.set(0)
            self.var_valid.set(0)
            self.var_errors.set(0)
        elif cmd == "task_end":
            # print(cmd)
            self.btn_start.configure(state="normal")
            self.task = None
        elif cmd == "task_progress":
            # print(cmd, data)
            self.var_processed.set(data["processed"])
            self.var_valid.set(data["valid"])
            self.var_errors.set(data["error"])

    def start_task(self):
        if self.task is None:
            self.task = BackgroundTask(self.queue)
            self.task.start()
            self.btn_start.configure(state="disabled")


if __name__ == "__main__":
    app = Demo227App()
    app.run()

demo227.ui

<?xml version='1.0' encoding='utf-8'?>
<interface version="1.3">
  <object class="tk.Toplevel" id="toplevel1">
    <property name="height">200</property>
    <property name="title" translatable="yes">Simple threading demo</property>
    <property name="width">200</property>
    <child>
      <object class="ttk.Frame" id="frame1">
        <property name="height">200</property>
        <property name="padding">4</property>
        <property name="width">200</property>
        <layout manager="pack">
          <property name="expand">true</property>
          <property name="fill">both</property>
          <property name="side">top</property>
        </layout>
        <child>
          <object class="ttk.Button" id="btn_start" named="True">
            <property name="command" type="command" cbtype="simple">start_task</property>
            <property name="text" translatable="yes">Start Task</property>
            <layout manager="pack">
              <property name="pady">10</property>
              <property name="side">top</property>
            </layout>
          </object>
        </child>
        <child>
          <object class="tk.LabelFrame" id="labelframe1">
            <property name="height">200</property>
            <property name="padx">2</property>
            <property name="pady">2</property>
            <property name="text" translatable="yes">Background task info:</property>
            <property name="width">200</property>
            <layout manager="pack">
              <property name="expand">true</property>
              <property name="fill">both</property>
              <property name="side">top</property>
            </layout>
            <containerlayout manager="grid">
              <property type="col" id="all" name="pad">2</property>
              <property type="row" id="all" name="pad">4</property>
            </containerlayout>
            <child>
              <object class="ttk.Label" id="label1">
                <property name="text" translatable="yes">Processed:</property>
                <layout manager="grid">
                  <property name="column">0</property>
                  <property name="row">0</property>
                </layout>
              </object>
            </child>
            <child>
              <object class="ttk.Label" id="label2">
                <property name="text" translatable="yes">Errors:</property>
                <layout manager="grid">
                  <property name="column">0</property>
                  <property name="row">1</property>
                </layout>
              </object>
            </child>
            <child>
              <object class="ttk.Entry" id="entry1">
                <property name="state">readonly</property>
                <property name="textvariable">int:var_processed</property>
                <layout manager="grid">
                  <property name="column">1</property>
                  <property name="row">0</property>
                </layout>
              </object>
            </child>
            <child>
              <object class="ttk.Entry" id="entry2">
                <property name="state">readonly</property>
                <property name="textvariable">int:var_errors</property>
                <layout manager="grid">
                  <property name="column">1</property>
                  <property name="row">1</property>
                </layout>
              </object>
            </child>
            <child>
              <object class="ttk.Label" id="label3">
                <property name="text" translatable="yes">Valid:</property>
                <layout manager="grid">
                  <property name="column">0</property>
                  <property name="row">2</property>
                </layout>
              </object>
            </child>
            <child>
              <object class="ttk.Entry" id="entry3">
                <property name="state">readonly</property>
                <property name="textvariable">int:var_valid</property>
                <layout manager="grid">
                  <property name="column">1</property>
                  <property name="row">2</property>
                </layout>
              </object>
            </child>
          </object>
        </child>
      </object>
    </child>
  </object>
</interface>

[Mike-152]

Hello Alejandro,
Thank you for your reply.
It's my turn to apologize for the delay, but I was 'off' for a few days...
Jobin's answer had already answered my questions, and I was referring to one of his tutorials: "Tkinter - Multithreading".
But I'll look at your proposal with interest.
Have a nice day!