Как использовать Gtk.events_pending? - PullRequest
0 голосов
/ 20 сентября 2018

У меня есть это базовое «тестовое» приложение, в котором я хотел бы отобразить счетчик, пока он выполняет свой длинный запуск процесса (функций с запросами к базе данных), чтобы пользователь знал, что ононе глючит, а запускается.Я читал в других постах, что это можно сделать с помощью функции Gtk.events_pending(), но я не знаю, как и где ее использовать.Я пробовал много способов, но главное окно всегда отображается только после выполнения запросов:

Вот основной файл .py:

#!/usr/bin/python3
# -*- coding: Utf-8 -*-

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk, GdkPixbuf, GObject

import Mng,os.path

path = os.path.dirname(os.path.realpath(__file__))

# MAIN WINDOW ######################################################################################
class PyApp:
    def __init__(self):
        builder = Gtk.Builder()
        builder.add_from_file(path + "/test.glade")
        self.obj = builder.get_object

        """
        I would like to display on main window a
        spinner while doing requests. There is a
        self.obj('spinner') in main window,
        in glade file to do so.
        """ 
        self.do_requests()

        self.obj('main').show_all()

    def do_requests(self):
        mng = Mng.Grab([
            [1,'getPlayers'],
            [2,'getFactions'],
            [3,'getBoards']
        ])
        data = mng.grab_data()
        players, nb = data[1]
        factions, nb = data[2]
        boards, nb = data[3]

        """
         Here will be the code to display data in GUI,
         like for example : self.obj('label_players').set_text(str(players))
        """

if __name__ == "__main__":
    app = PyApp()
    Gtk.main()

Вот файл Mng.py вкоторый я буду обрабатывать все свои запросы в классе (я не знаю, хорошо ли он закодирован, потому что я только что обнаружил многопоточность. Но он делает свое дело):

#!/usr/bin/python3
# -*- coding: Utf-8 -*-
import os.path, DB
import concurrent.futures

path = os.path.dirname(os.path.realpath(__file__))


class Grab:    
    """
    Retrieves multiple database requests datas
    & returns results in a dict : {name of request: [result, lenght of result]}
    """
    def __init__(self, req_list):
        self.req_list = req_list

    def grab_data(self):

        def do_req(var, funct_name, args):
            if None in args:
                funct = getattr(self, str(funct_name))()
            else:
                #print("function",name,"*args : ", *args)
                funct = getattr(self, str(funct_name))(*args)
            res = [var, funct]
            return res

        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
            res_list = {}
            future_to_req = {executor.submit(do_req, req[0], req[1], req[2:]): req for req in self.req_list}
            for future in concurrent.futures.as_completed(future_to_req):
                req = future_to_req[future]
                try:
                    data = future.result()
                except Exception as exc:
                    print('%r generated an exception: %s' % (req, exc))
                else:
                    res_list[data[0]] = data[1]

        return res_list

    def getFactions(self, ext1=False):
        req = DB.DB('SELECT * FROM factions')
        res = req.res
        nb = len(res)
        return res, nb

    def getBoards(self, ext1=False):
        req = DB.DB('SELECT * FROM boards')
        res = req.res
        nb = len(res)
        return res, nb


    def getPlayers(self):
        req = DB.DB('SELECT * FROM players')
        res = req.res
        nb = len(res)
        return res, nb

И файл DB.pyвыполнение запросов:

#!/usr/bin/python3
# -*- coding: Utf-8 -*-

import mysql.connector as sql

class DB(object):    
    """DB initializes and manipulates MySQL databases."""

    def __init__(self, query):
        """Initialize a new or connect to an existing database.
        Accept setup statements to be executed.
        """
        self.database = '******'
        self.host = '**********'
        self.port = '********'
        self.user = '******'
        self.password = '***********'
        self.connect()
        self.execute(query)
        self.close()            

    def connect(self):
        """Connect to the MySQL database."""

        self.connection = sql.connect(host=self.host,port=self.port,user=self.user,password=self.password, database=self.database)
        self.cursor = self.connection.cursor()
        self.connected = True

    def close(self): 
        """Close the MySQL database."""

        self.connection.close()
        self.connected = False

    def execute(self, query):
        """Execute complete SQL statements. """
        res = close = False
        if not self.connected:
            self.connect()
            close = True

        try:
            self.cursor.execute(query)
            if query.upper().startswith('SELECT'):
                res = self.cursor.fetchall()

        except sql.Error as e:
            try:
                print ("MySQL Error [%d]: %s" % (e.args[0], e.args[1]))
            except IndexError:
                print ("MySQL Error: %s" % str(e))

        if close:
            self.close()   

        self.res = res    

Подскажите, пожалуйста, как это сделать?

1 Ответ

0 голосов
/ 21 сентября 2018

Это может помочь вам понять, как должна работать многопроцессорная обработка.Извините, но я не могу дать вам полную демонстрацию со встроенным кодом, но, надеюсь, вы сможете это выяснить.

#!/usr/bin/env python3

from gi.repository import Gtk, GLib, Gdk
from multiprocessing import Queue, Process
from queue import Empty
import os, sys, time

UI_FILE = "src/pygtk_foobar.ui"

class GUI:
    def __init__(self):

        self.builder = Gtk.Builder()
        self.builder.add_from_file(UI_FILE)
        self.builder.connect_signals(self)

        self.window1 = self.builder.get_object('window1')
        self.window1.show_all()
        self.builder.get_object('spin1').start()

        self.data_queue = Queue()
        thread = Process(target=self.thread_start)
        thread.start()

        GLib.timeout_add(100, self.get_result )

    def thread_start (self):
        time.sleep(5)
        self.data_queue.put("done")

    def get_result (self):
        try:
            result = self.data_queue.get_nowait()
            print (result)
            self.builder.get_object('spin1').stop()
        except Empty:
            return True

    def on_window_destroy(self, window):
        Gtk.main_quit()

def main():
    app = GUI()
    Gtk.main()

if __name__ == "__main__":
    sys.exit(main())

РЕДАКТИРОВАТЬ

Объяснение: GLib.timeout_add () будет продолжать опрос до тех пор, пока get result вернет True.Когда тайм-аут возвращается «Нет» или «Ложь», он прекращает опрос.get result попытается получить результаты из data_queue, но если ничего не найдено, он вернет True.

В вашем случае вы открываете запросы к базе данных с помощью def thread_start и проверяете очередь с помощью def get_result, пока информация не будет загружена.Таким образом, мультипроцессор будет загружать информацию о БД в одном потоке, в то время как Gtk может рисовать окно в другом потоке, периодически проверяя, завершен ли многопроцессорный поток БД.Когда загрузка закончится, отмените таймаут, не возвращая True, и сделайте свое дело с данными db.

Я часто использую это для заполнения сканеров, например, пока пользователь может работать с графическим интерфейсом.

Надеюсь, это поможет.

...