reclosedev / async_gui Goto Github PK

Easy threading and multiprocessing for GUI applications

Home Page: https://pypi.python.org/pypi/async_gui/

License: BSD 2-Clause "Simplified" License

Python 100.00%

async_gui's Introduction

async_gui

async_gui is a library aimed to make use of threads in GUI applications simpler. It's inspired by PyCon talk Using futures for async GUI programming in Python 3.3 and tornado @gen.engine implementation.

Most of GUI toolkits don't allow you to access graphical elements from non-GUI thread. Python 3.2+ has nice new feature concurrent.futures, but we can't just wait for result from future and callbacks are not very handy.

Combination of Coroutines via Enhanced Generators (PEP-342) and futures creates a rich and easy to use asynchronous programming model which can be used for creating highly responsive GUI applications.

Example

Demo of button click handler:

@engine.async
def on_button_click(self, *args):
    self.status_label.setText("Downloading image...")
    # Run single task in separate thread
    image_data = yield Task(self.load_url,
                            "http://www.google.com/images/srpr/logo4w.png")
    pixmap = QtGui.QPixmap.fromImage(QtGui.QImage.fromData(image_data))
    self.image_label.setPixmap(pixmap)
    self.status_label.setText("Downloading pages...")
    urls = ['http://www.google.com',
            'http://www.yandex.ru',
            'http://www.python.org']
    # Run multiple task simultaneously in thread pool
    pages = yield [Task(self.load_url, url) for url in urls]
    self.status_label.setText("Done")
    avg_size = sum(map(len, pages)) / len(pages)
    self.result_label.setText("Average page size: %s" % avg_size)

Tasks yielded from on_button_click() executed in thread pool, but GUI updates done in the GUI thread. For CPU-bound applications there is also ability to run tasks in pool of processes.

See full example in examples directory.

Features

Python 2.7+ (futures required), Python 3+ support
PyQt4/PySide, Tk, Wx, Gtk GUI toolkits support. Easy to add another
Can execute tasks in Thread, Process, Greenlet (gevent required)
Possibility to run multiple tasks at the same time
Straightforward exception handling
Full test coverage

Installation

Using pip:

$ pip install async_gui

Or download, unpack and:

$ python setup.py install

To run tests use:

$ python setup.py test

async_gui's People

Contributors

Stargazers

Watchers

Forkers

karelin testmana2 timeyyy brsaylor blitzmann robertpro ctoth kiritozzl janpeldrimovsky randomdeveloperm rlatienza avinzent

async_gui's Issues

QCoreApplication.processEvents got QEventLoop.ProcessEventsFlag instead of QEventLoop.ProcessEventsFlags (should be plural?)

I got this traceback while runn async_gui in a Pyside app:

Traceback (most recent call last):
  File "C:\Python27\lib\site-packages\async_gui\engine.py", line 81, in wrapper
    return self.create_runner(gen).run()
  File "C:\Python27\lib\site-packages\async_gui\engine.py", line 136, in run
    task = self._execute_single_task(gen, executor, task)
  File "C:\Python27\lib\site-packages\async_gui\engine.py", line 149, in _execute_single_task
    self.engine.update_gui()
  File "C:\Python27\lib\site-packages\async_gui\toolkits\_qt.py", line 14, in update_gui
    int(self.pool_timeout * 1000)
TypeError: arguments did not match any overloaded call:
  QCoreApplication.processEvents(QEventLoop.ProcessEventsFlags flags=QEventLoop.AllEvents): argument 1 has unexpected type 'PySide.QtCore.QEventLoop.ProcessEventsFlag'
  QCoreApplication.processEvents(QEventLoop.ProcessEventsFlags, int): argument 1 has unexpected type 'PySide.QtCore.QEventLoop.ProcessEventsFlag'

I check the Qt doc the argument should be QEventLoop.ProcessEventsFlags, but I got QeventLoop.ProcessEventsFlag (single not plural) instead.

When an exception occurs in a future, we lose most of the traceback

Consider the following:


def bad():
    worse()

def worse():
    raise RuntimeError("Bad Day")

Currently, if this code gets executed in a Task, we'll lose the traceback, only the last line will show up.
When I ran across this problem with Python Futures in my own code, I came up with a janky solution with a subclassed Executor class, perhaps you can think of something better than this for async_gui, which is awesome btw, thank you.

class CustomExecutor(concurrent.futures.thread.ThreadPoolExecutor):

    def submit(self, task, *args, **kwargs):
        @functools.wraps(task)
        def task_wrapper():
            try:
                return task(*args, **kwargs)
            except Exception as e:
                logger.exception("Error executing %r with args %r and kwargs %r" % (task, args, kwargs))
                raise
        future = super(CustomExecutor, self).submit(task_wrapper)
        return future

update pypi

Would we able to get a pypi update with the kivy version?

Async functions raise StopIteration unless they yield

This example async function will raise StopIteration if called, instead of just returning:

@async
def test():
    print "Don't need to yield"
    return
    yield Task(hello_world)

def hello_world():
    print "Hello world"

My initial try at a fix is to subclass Runner and my desired engine to ignore StopIteration.

class CustomRunner(Runner):

    def run(self):
        try:
            return super(CustomRunner, self).run()
        except StopIteration:
            pass

class CustomEngine(Engine):

    def create_runner(self, gen):
        return CustomRunner(self, gen)

asyncio support

For python2.7 support we will need to use a compatibility layer.
http://trollius.readthedocs.io/using.html

trollius uses the same api as asyncio.

The work involves mainly implementing the AbstractEventLoop
https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.AbstractEventLoop

Kivy is not include

Hi guys your lib in https://pypi.org/project/async_gui/ is not the latest version, Kivy is not include