Review public/private

QTrio - a library bringing Qt GUIs together with `async` and `await` via Trio

Resources

Documentation	Read the Docs
Chat	Gitter
Forum	Discourse
Issues	GitHub
Repository	GitHub
Tests	GitHub Actions
Coverage	Codecov
Distribution	PyPI

Introduction

Note:: This library is in early development. It works. It has tests. It has documentation. Expect breaking changes as we explore a clean API. By paying this price you get the privilege to provide feedback via GitHub issues to help shape our future. :]

The QTrio project's goal is to bring the friendly concurrency of Trio using Python's async and await syntax together with the GUI features of Qt to enable more correct code and a more pleasant developer experience. QTrio is permissively licensed to avoid introducing restrictions beyond those of the underlying Python Qt library you choose. Both PySide2 and PyQt5 are supported.

By enabling use of async and await it is possible in some cases to write related code more concisely and clearly than you would get with the signal and slot mechanisms of Qt concurrency. In this set of small examples we will allow the user to input their name then use that input to generate an output message. The user will be able to cancel the input to terminate the program early. In the first example we will do it in the form of a classic "hello" console program. Well, classic plus a bit of boilerplate to allow explicit testing without using special external tooling. Then second, the form of a general Qt program implementing this same activity. And finally, the QTrio way.

# A complete runnable source file with imports and helpers is available in
# either the documentation readme examples or in the repository under
# qtrio/examples/readme/console.py.

def main(
    input_file: typing.TextIO = sys.stdin, output_file: typing.TextIO = sys.stdout
) -> None:
    try:
        output_file.write("What is your name? ")
        output_file.flush()
        name = input_file.readline()[:-1]
        output_file.write(f"Hi {name}, welcome to the team!\n")
    except KeyboardInterrupt:
        pass

Nice and concise, including the cancellation via ctrl+c. This is because we can stay in one scope thus using both local variables and a try/except block. This kind of explodes when you shift into a classic Qt GUI setup.

# A complete runnable source file with imports and helpers is available in
# either the documentation readme examples or in the repository under
# qtrio/examples/readme/qt.py.

class Main:
    def __init__(
        self,
        application: QtWidgets.QApplication,
        input_dialog: typing.Optional[QtWidgets.QInputDialog] = None,
        output_dialog: typing.Optional[QtWidgets.QMessageBox] = None,
    ):
        self.application = application

        if input_dialog is None:  # pragma: no cover
            input_dialog = create_input()

        if output_dialog is None:  # pragma: no cover
            output_dialog = create_output()

        self.input_dialog = input_dialog
        self.output_dialog = output_dialog

    def setup(self) -> None:
        self.input_dialog.accepted.connect(self.input_accepted)
        self.input_dialog.rejected.connect(self.input_rejected)

        self.input_dialog.show()

    def input_accepted(self) -> None:
        name = self.input_dialog.textValue()

        self.output_dialog.setText(f"Hi {name}, welcome to the team!")

        self.output_dialog.finished.connect(self.output_finished)
        self.output_dialog.show()

    def input_rejected(self) -> None:
        self.application.quit()

    def output_finished(self) -> None:
        self.application.quit()

The third example, below, shows how using async and await allows us to return to the more concise and clear description of the sequenced activity. Most of the code is just setup for testability with only the last four lines really containing the activity.

# A complete runnable source file with imports and helpers is available in
# either the documentation readme examples or in the repository under
# qtrio/examples/readme/qtrio_example.py.

async def main(
    *,
    task_status: trio_typing.TaskStatus[Dialogs] = trio.TASK_STATUS_IGNORED,
) -> None:
    dialogs = Dialogs()
    task_status.started(dialogs)

    with contextlib.suppress(qtrio.UserCancelledError):
        name = await dialogs.input.wait()
        dialogs.output.text = f"Hi {name}, welcome to the team!"
        await dialogs.output.wait()

	def test_overrunning_test_times_out(testdir):
	"""The overrunning test is timed out."""

	test_file = rf"""
	import qtrio
	import trio

	@qtrio.host
	async def test(request):
	await trio.sleep({2 * qtrio._pytest.timeout})
	"""
	testdir.makepyfile(test_file)

	timeout = qtrio._pytest.timeout

	result = testdir.runpytest_subprocess(timeout=2 * qtrio._pytest.timeout)
	result.assert_outcomes(failed=1)
	result.stdout.re_match_lines(
	lines2=[f"E AssertionError: test not finished within {timeout} seconds"],
	)

	def test_hosted_assertion_failure_fails(testdir):
	"""QTrio hosted test which fails an assertion fails the test."""

	test_file = r"""
	import qtrio

	@qtrio.host
	async def test(request):
	assert False
	"""
	testdir.makepyfile(test_file)

	result = testdir.runpytest_subprocess(timeout=10)
	result.assert_outcomes(failed=1)

	REENTER_EVENT_HINT: int = QtCore.QEvent.registerEventType()
	if REENTER_EVENT_HINT == -1:
	message = (
	"Failed to register the event hint, either no available hints remain or the"
	+ " program is shutting down."
	)
	raise qtrio.RegisterEventTypeError(message)

	def unwrap(self):
	"""Unwrap either the Trio or Qt outcome. First, errors are given priority over
	success values. Second, the Trio outcome gets priority over the Qt outcome. If
	both are still None a :class:`NoOutcomesError` is raised.
	"""

	if self.trio is not None:
	# highest priority to the Trio outcome, if it is an error we are done
	result = self.trio.unwrap()

	# since a Trio result is higher priority, we only care if Qt gave an error
	if self.qt is not None:
	self.qt.unwrap()

	# no Qt error so go ahead and return the Trio result
	return result
	elif self.qt is not None:
	# either it is a value that gets returned or an error that gets raised
	return self.qt.unwrap()

	# neither Trio nor Qt outcomes have been set so we have nothing to unwrap()
	raise qtrio.NoOutcomesError()

altendky / qtrio Goto Github PK

qtrio's Introduction

QTrio - a library bringing Qt GUIs together with async and await via Trio

Resources

Introduction

qtrio's People

Contributors

Stargazers

Watchers

Forkers

qtrio's Issues

Recommend Projects

Recommend Topics

Recommend Org

QTrio - a library bringing Qt GUIs together with `async` and `await` via Trio