Python-сообщество

self.queue = queue.Queue()

def threadMain(self):

import queue

while True:
   try:
      target = self.queue.get_nowait()
   except queue.Empty:              
      return 0

import queue
import time

class A(object):
    def __init__(self):
        self.queue = queue.Queue()

   def put(self, val):
        self.queue.put(val)

   def process(self):
        while True:
            try:
                val = self.queue.get_nowait()
                # process val
            except queue.Empty:
                time.sleep(1) # just for example

    def get(self, block=True, timeout=None):
        """Remove and return an item from the queue.

        If optional args 'block' is true and 'timeout' is None (the default),
        block if necessary until an item is available. If 'timeout' is
        a positive number, it blocks at most 'timeout' seconds and raises
        the Empty exception if no item was available within that time.
        Otherwise ('block' is false), return an item if one is immediately
        available, else raise the Empty exception ('timeout' is ignored
        in that case).
        """
        self.not_empty.acquire()
        try:
            if not block:
                if not self._qsize():
                    raise Empty
            elif timeout is None:
                while not self._qsize():
                    self.not_empty.wait()
            elif timeout < 0:
                raise ValueError("'timeout' must be a positive number")
            else:
                endtime = _time() + timeout
                while not self._qsize():
                    remaining = endtime - _time()
                    if remaining <= 0.0:
                        raise Empty
                    self.not_empty.wait(remaining)
            item = self._get()
            self.not_full.notify()
            return item
        finally:
            self.not_empty.release()

    def get_nowait(self):
        """Remove and return an item from the queue without blocking.

        Only get an item if one is immediately available. Otherwise
        raise the Empty exception.
        """
        return self.get(False)

        while True:
            try:
                acc = self.queue.get_nowait() 
            except queue.Empty:
                print('empty!')                    
                return 0

acc = self.queue.get_nowait()

import sys
import sip
from PyQt4 import QtCore, QtGui
from ui import Ui_Form
import queue

from lib import check

class run(QtGui.QMainWindow):

    def __init__(self, parent=None):       
        
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_Form()
        self.ui.setupUi(self)
        self.queue = queue.Queue()
        
        # connectors
        ###
        QtCore.QObject.connect(self.ui.button_start,
                               QtCore.SIGNAL("clicked()"),
                               self.start)        
        
    def unique(self): #       
    def load(self): #                                      
    def clear(self): #
    def setLabelTotal(self, num): # 
    def labelValidInc(self): #
    def labelInvalidInc(self): #
    def labelTotalDec(self): #
        
    def start(self):
        import threading        

        ''' check accounts mt '''            
        accs = self.ui.text_accs.toPlainText().splitlines()

        for acc in accs:
            self.queue.put(acc)

        for test in range(len(accs)):
           new_thread = threading.Thread(target=self.threadMain)
           new_thread.start()

        threading.Thread.join(new_thread)            

    def threadMain(self):
        ''' thread body '''
        global app

##        while True:
##            try:
##                acc = self.queue.get_nowait() 
##            except queue.Empty:
##                print('empty!')                    
##                return 0        

        acc = self.queue.get_nowait() # work

        res = check(acc) # thread body (not included)

        newAccsText = self.ui.text_accs.toPlainText().replace(acc, '')
          
        if res == 1:                             
            self.ui.text_accs_valid.appendPlainText(acc)
            self.labelValidInc()
        else:                                
            self.labelInvalidInc()
            
        self.ui.text_accs.setPlainText(newAccsText.strip()) 
        self.labelTotalDec()
        app.processEvents() # update gui            

##################################################################                    

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    myApp = run()
    myApp.show()

    sys.exit(app.exec_())

import sys
import sip
from PyQt4 import QtCore, QtGui
from ui import Ui_Form
#import queue
#import threading

# install from http://pypi.python.org/pypi/futures
# doc in http://www.python.org/dev/peps/pep-3148/
from concurency.futures import ThreadPoolExecutor

from lib import check

class run(QtGui.QMainWindow):

    def __init__(self, parent=None):

        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_Form()
        self.ui.setupUi(self)
        self.executor = ThreadPoolExecutor(max_workers=5) # should be relative small
        self.pending = set()
        self.queue = queue.Queue()

        # connectors
        ###
        QtCore.QObject.connect(self.ui.button_start,
                               QtCore.SIGNAL("clicked()"),
                               self.start)

    def closeEvent(self, event):
        event.accept()
        for p in self.pendings:
            p.cancel()
        self.executor.shutdown() # wait for processing all pending tasks

    def unique(self): pass#
    def load(self): pass#
    def clear(self): pass#
    def setLabelTotal(self, num): pass#
    def labelValidInc(self): pass#
    def labelInvalidInc(self): pass#
    def labelTotalDec(self): pass#

    def start(self):

        ''' check accounts mt '''
        accs = self.ui.text_accs.toPlainText().splitlines()

        for acc in accs:
            future = self.executor.submit(self.worker, acc)
            self.pending.add(future)
            future.add_done_callback(self.process_result)

    def process_result(self, future):
        # callback is called in main thread
        # it's good practice to communicate with UI in main thread only

        self.pending.discard(future)

        if future.cancelled():
            # cancelled on shutdown
            return

        acc, res = future.result()
        newAccsText = self.ui.text_accs.toPlainText().replace(acc, '')

        if res == 1:
            self.ui.text_accs_valid.appendPlainText(acc)
            self.labelValidInc()
        else:
            self.labelInvalidInc()

        self.ui.text_accs.setPlainText(newAccsText.strip())
        self.labelTotalDec()


    def worker(self, acc):
        # worker precesses own code in one of executor threads
        res = check(acc) # thread body (not included)
        return acc, res


##################################################################

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    myApp = run()
    myApp.show()

    sys.exit(app.exec_())