Find similar content

https://wiki.python.org/moin/PyQt #PyQt is one of the two most popular Python bindings for the #Qt cross-platform #GUI/#XML/#SQL#C++ framework (another binding is #PySide).

http://tech-artists.org/t/pyqt-model-view-video-tutorial-series-part-01/1401 [#PyQT] Model View Video Tutorial Series (Part 01)

https://docs.python.org/3/library/asyncio-dev.html#asyncio-multithreading 18.5.9.3. #Concurrency and #multithreading An event loop runs in a thread and executes all callbacks and tasks in the same thread. While a task is running in the event loop, no other task is running in the same thread. But when the task uses yield from, the task is suspended and the event loop executes the next task. To schedule a callback from a different thread, the BaseEventLoop.call_soon_threadsafe() method should be used. Example: loop.call_soon_threadsafe(callback, *args) Most asyncio objects are not thread safe. You should only worry if you access objects outside the event loop. For example, to cancel a future, don’t call directly its Future.cancel() method, but: loop.call_soon_threadsafe(fut.cancel) To handle signals and to execute subprocesses, the event loop must be run in the main thread. To schedule a coroutine object from a different thread, the run_coroutine_threadsafe() function should be used. It returns a concurrent.futures.Future to access the result: future = asyncio.run_coroutine_threadsafe(coro_func(), loop) result = future.result(timeout) # Wait for the result with a timeout The BaseEventLoop.run_in_executor() method can be used with a thread pool executor to execute a callback in different thread to not block the thread of the event loop. See also The Synchronization primitives section describes ways to synchronize tasks. The Subprocess and threads section lists asyncio limitations to run subprocesses from different threads.

https://docs.python.org/3/library/asyncio-task.html#asyncio.run_coroutine_threadsafe #asyncio.run_coroutine_threadsafe(coro, loop) Submit a coroutine object to a given event loop. Return a concurrent.futures.Future to access the result.

https://docs.python.org/3/library/asyncio-eventloop.html The event loop is the central execution device provided by #asyncio. It provides multiple facilities, including: Registering, executing and cancelling delayed calls (timeouts). Creating client and server transports for various kinds of communication. Launching subprocesses and the associated transports for communication with an external program. Delegating costly function calls to a pool of threads.

https://vorpus.org/blog/some-thoughts-on-asynchronous-api-design-in-a-post-asyncawait-world/#websocket-servers I've recently been exploring the exciting new world of #asynchronous I/O libraries in Python 3 – specifically asyncio and curio. These two libraries make some different design choices. Example 1: #asyncio, with callbacks Example 2: #curio, with #async/#await Example 3: asyncio, with async/await #websockets

https://groups.google.com/forum/#!topic/pyside-dev/pqwzngAGLWE Dear #Pyside2 contributors, As you might know, Pyside was originally developed for Nokia while it was the owner of the #Qt technology. When Nokia sold Qt to Digia (and now The Qt Company), all the copyrights over the original Pyside code for Qt 4 got transferred to The Qt Company as well. For different reasons, it was not possible for The Qt Company to push Pyside forward as much as we would have wished over the last few years. Fortunately this changed now, and The Qt Company is today in a position, where it can and will invest into Pyside. The goal is to ensure Pyside becomes a fully supported part of the Qt product family, with a similar development and licensing model as the rest of Qt. We want to make sure Pyside works on new Qt releases when they come out and are committed to invest long term into the technology.

https://www.obeythetestinggoat.com/testing-async-asyncio-and-performance.html #Testing, #async, #asyncio, and #performance Sun 27 December 2015 By Harry I recently did some experimenting with asyncio, and wanted to report back on how I got on with writing tests for it. While I was at it I was also able to compare its performance with a couple of other approaches to #mutlitasking in Python, namely #threads and #gevent, so I'll report on that here too. (tl;dr: it's much of a muchness).

https://wxpython.org/what.php #wxPython is a #GUI toolkit for the Python programming language. It allows Python programmers to create programs with a robust, highly functional graphical user interface, simply and easily. It is implemented as a Python extension module (native code) that wraps the popular wxWidgets cross platform GUI library, which is written in C++.

https://wiki.python.org/moin/GuiProgramming #GUI Programming in Python Python has a huge number of GUI frameworks (or toolkits) available for it, from #TkInter (traditionally bundled with Python, using Tk) to a number of other cross-platform solutions, as well as bindings to platform-specific (also known as "native") technologies. GUI Programming in Python is a similar page whose content could arguably complement this page with some editing.