Группа :: Development/Python3
Пакет: python3-module-Quamash
Главная Изменения Спек Патчи Sources Загрузить Gear Bugs and FR Repocop
Патч: python3-module-Quamash-0.6.1-alt.patch
Скачать
Скачать
quamash/__init__.py | 14 ++++---
quamash/_unix.py | 2 +-
tests/test_qeventloop.py | 96 +++++++++++++++++++++---------------------------
3 files changed, 52 insertions(+), 60 deletions(-)
diff --git a/quamash/__init__.py b/quamash/__init__.py
index 1c16118..97a4c84 100644
--- a/quamash/__init__.py
+++ b/quamash/__init__.py
@@ -180,7 +180,11 @@ class _SimpleTimer(QtCore.QObject):
self._stopped = False
def add_callback(self, handle, delay=0):
- timerid = self.startTimer(delay * 1000)
+ """
+ delay should be in seconds(float or int), while
+ startTimer accepts milliseconds(int)
+ """
+ timerid = self.startTimer(round(delay * 1000))
self._logger.debug("Registering timer id {0}".format(timerid))
assert timerid not in self.__callbacks
self.__callbacks[timerid] = handle
@@ -225,14 +229,14 @@ class _QEventLoop:
>>>
>>> app = getfixture('application')
>>>
- >>> @asyncio.coroutine
- ... def xplusy(x, y):
- ... yield from asyncio.sleep(.1)
+ ... async def xplusy(x, y):
+ ... await asyncio.sleep(.1)
... assert x + y == 4
- ... yield from asyncio.sleep(.1)
+ ... await asyncio.sleep(.1)
>>>
>>> loop = QEventLoop(app)
>>> asyncio.set_event_loop(loop)
+ >>> asyncio.events._set_running_loop(loop)
>>> with loop:
... loop.run_until_complete(xplusy(2, 2))
"""
diff --git a/quamash/_unix.py b/quamash/_unix.py
index 0e7137e..f39c655 100644
--- a/quamash/_unix.py
+++ b/quamash/_unix.py
@@ -41,7 +41,7 @@ def _fileobj_to_fd(fileobj):
return fd
-class _SelectorMapping(collections.Mapping):
+class _SelectorMapping(collections.abc.Mapping):
"""Mapping of file objects to selector keys."""
diff --git a/tests/test_qeventloop.py b/tests/test_qeventloop.py
index ba6f674..0cccbb4 100644
--- a/tests/test_qeventloop.py
+++ b/tests/test_qeventloop.py
@@ -20,6 +20,7 @@ import pytest
def loop(request, application):
lp = quamash.QEventLoop(application)
asyncio.set_event_loop(lp)
+ asyncio.events._set_running_loop(lp)
additional_exceptions = []
@@ -116,33 +117,30 @@ class TestCanRunTasksInExecutor:
was_invoked.value = 1
logging.debug('end blocking_func()')
- @asyncio.coroutine
- def blocking_task(self, loop, executor, was_invoked):
+ async def blocking_task(self, loop, executor, was_invoked):
logging.debug('start blocking task()')
fut = loop.run_in_executor(executor, self.blocking_func, was_invoked)
- yield from asyncio.wait_for(fut, timeout=5.0)
+ await asyncio.wait_for(fut, timeout=5.0)
logging.debug('start blocking task()')
def test_can_execute_subprocess(loop):
"""Verify that a subprocess can be executed."""
- @asyncio.coroutine
- def mycoro():
- process = yield from asyncio.create_subprocess_exec(
+ async def mycoro():
+ process = await asyncio.create_subprocess_exec(
sys.executable or 'python', '-c', 'import sys; sys.exit(5)')
- yield from process.wait()
+ await process.wait()
assert process.returncode == 5
loop.run_until_complete(asyncio.wait_for(mycoro(), timeout=3))
def test_can_read_subprocess(loop):
"""Verify that a subprocess's data can be read from stdout."""
- @asyncio.coroutine
- def mycoro():
- process = yield from asyncio.create_subprocess_exec(
+ async def mycoro():
+ process = await asyncio.create_subprocess_exec(
sys.executable or 'python', '-c', 'print("Hello async world!")', stdout=subprocess.PIPE)
- received_stdout = yield from process.stdout.readexactly(len(b'Hello async world!\n'))
- yield from process.wait()
+ received_stdout = await process.stdout.readexactly(len(b'Hello async world!\n'))
+ await process.wait()
assert process.returncode == 0
assert received_stdout.strip() == b'Hello async world!'
@@ -151,12 +149,11 @@ def test_can_read_subprocess(loop):
def test_can_communicate_subprocess(loop):
"""Verify that a subprocess's data can be passed in/out via stdin/stdout."""
- @asyncio.coroutine
- def mycoro():
- process = yield from asyncio.create_subprocess_exec(
+ async def mycoro():
+ process = await asyncio.create_subprocess_exec(
sys.executable or 'python', '-c', 'print(input())', stdout=subprocess.PIPE, stdin=subprocess.PIPE)
- received_stdout, received_stderr = yield from process.communicate(b'Hello async world!\n')
- yield from process.wait()
+ received_stdout, received_stderr = await process.communicate(b'Hello async world!\n')
+ await process.wait()
assert process.returncode == 0
assert received_stdout.strip() == b'Hello async world!'
loop.run_until_complete(asyncio.wait_for(mycoro(), timeout=3))
@@ -165,12 +162,11 @@ def test_can_communicate_subprocess(loop):
def test_can_terminate_subprocess(loop):
"""Verify that a subprocess can be terminated."""
# Start a never-ending process
- @asyncio.coroutine
- def mycoro():
- process = yield from asyncio.create_subprocess_exec(
+ async def mycoro():
+ process = await asyncio.create_subprocess_exec(
sys.executable or 'python', '-c', 'import time\nwhile True: time.sleep(1)')
process.terminate()
- yield from process.wait()
+ await process.wait()
assert process.returncode != 0
loop.run_until_complete(mycoro())
@@ -186,8 +182,7 @@ def test_loop_callback_exceptions_bubble_up(loop):
def test_loop_running(loop):
"""Verify that loop.is_running returns True when running."""
- @asyncio.coroutine
- def is_running():
+ async def is_running():
nonlocal loop
assert loop.is_running()
@@ -217,7 +212,8 @@ def test_future_not_done_on_loop_shutdown(loop):
def test_call_later_must_not_coroutine(loop):
"""Verify TypeError occurs call_later is given a coroutine."""
- mycoro = asyncio.coroutine(lambda: None)
+ async def mycoro():
+ return None
with pytest.raises(TypeError):
loop.call_soon(mycoro)
@@ -479,15 +475,14 @@ def test_reader_writer_echo(loop, sock_pair):
"""Verify readers and writers can send data to each other."""
c_sock, s_sock = sock_pair
- @asyncio.coroutine
- def mycoro():
- c_reader, c_writer = yield from asyncio.open_connection(sock=c_sock)
- s_reader, s_writer = yield from asyncio.open_connection(sock=s_sock)
+ async def mycoro():
+ c_reader, c_writer = await asyncio.open_connection(sock=c_sock)
+ s_reader, s_writer = await asyncio.open_connection(sock=s_sock)
data = b'Echo... Echo... Echo...'
s_writer.write(data)
- yield from s_writer.drain()
- read_data = yield from c_reader.readexactly(len(data))
+ await s_writer.drain()
+ read_data = await c_reader.readexactly(len(data))
assert data == read_data
s_writer.close()
@@ -499,22 +494,20 @@ def test_regression_bug13(loop, sock_pair):
c_sock, s_sock = sock_pair
client_done, server_done = asyncio.Future(), asyncio.Future()
- @asyncio.coroutine
- def server_coro():
- s_reader, s_writer = yield from asyncio.open_connection(sock=s_sock)
+ async def server_coro():
+ s_reader, s_writer = await asyncio.open_connection(sock=s_sock)
s_writer.write(b'1')
- yield from s_writer.drain()
- assert (yield from s_reader.readexactly(1)) == b'2'
+ await s_writer.drain()
+ assert (await s_reader.readexactly(1)) == b'2'
s_writer.write(b'3')
- yield from s_writer.drain()
+ await s_writer.drain()
server_done.set_result(True)
result1 = None
result3 = None
- @asyncio.coroutine
- def client_coro():
+ async def client_coro():
def cb1():
nonlocal result1
assert result1 is None
@@ -570,20 +563,18 @@ def test_add_reader_replace(loop, sock_pair):
called2 = True
any_callback()
- @asyncio.coroutine
- def server_coro():
- s_reader, s_writer = yield from asyncio.open_connection(
+ async def server_coro():
+ s_reader, s_writer = await asyncio.open_connection(
sock=s_sock)
s_writer.write(b"foo")
- yield from s_writer.drain()
+ await s_writer.drain()
- @asyncio.coroutine
- def client_coro():
+ async def client_coro():
loop.add_reader(c_sock.fileno(), callback1)
loop.add_reader(c_sock.fileno(), callback2)
- yield from callback_invoked
+ await callback_invoked
loop.remove_reader(c_sock.fileno())
- assert (yield from loop.sock_recv(c_sock, 3)) == b"foo"
+ assert (await loop.sock_recv(c_sock, 3)) == b"foo"
client_done = asyncio.ensure_future(client_coro())
server_done = asyncio.ensure_future(server_coro())
@@ -620,11 +611,10 @@ def test_add_writer_replace(loop, sock_pair):
called2 = True
any_callback()
- @asyncio.coroutine
- def client_coro():
+ async def client_coro():
loop.add_writer(c_sock.fileno(), callback1)
loop.add_writer(c_sock.fileno(), callback2)
- yield from callback_invoked
+ await callback_invoked
loop.remove_writer(c_sock.fileno())
loop.run_until_complete(asyncio.wait_for(client_coro(), timeout=0.1))
@@ -693,8 +683,7 @@ def test_exception_handler(loop):
coro_run = False
loop.set_debug(True)
- @asyncio.coroutine
- def future_except():
+ async def future_except():
nonlocal coro_run
coro_run = True
loop.stop()
@@ -730,10 +719,9 @@ def test_exception_handler_simple(loop):
def test_not_running_immediately_after_stopped(loop):
- @asyncio.coroutine
- def mycoro():
+ async def mycoro():
assert loop.is_running()
- yield from asyncio.sleep(0)
+ await asyncio.sleep(0)
loop.stop()
assert not loop.is_running()
assert not loop.is_running()