--- Begin Message ---
Source: pymodbus
Version: 3.0.0-5
Severity: serious
Justification: FTBFS
Tags: bookworm sid ftbfs
User: [email protected]
Usertags: ftbfs-20230113 ftbfs-bookworm
Hi,
During a rebuild of all packages in sid, your package failed to build
on amd64.
Relevant part (hopefully):
> make[1]: Entering directory '/<<PKGBUILDDIR>>'
> PYTHONPATH=/<<PKGBUILDDIR>> dh_auto_test
> I: pybuild base:240: cd
> /<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build; python3.11 -m pytest
> test
> ============================= test session starts
> ==============================
> platform linux -- Python 3.11.1, pytest-7.2.0, pluggy-1.0.0+repack
> rootdir: /<<PKGBUILDDIR>>, configfile: setup.cfg
> plugins: cov-4.0.0, asyncio-0.20.3
> asyncio: mode=Mode.AUTO
> collected 443 items
>
> test/test_all_messages.py ... [
> 0%]
> test/test_bit_read_messages.py ......... [
> 2%]
> test/test_bit_write_messages.py ......... [
> 4%]
> test/test_client.py .................................................... [
> 16%]
> .. [
> 16%]
> test/test_client_sync.py ............................ [
> 23%]
> test/test_client_sync_diag.py ..... [
> 24%]
> test/test_datastore.py ............................... [
> 31%]
> test/test_device.py ..................... [
> 36%]
> test/test_diag_messages.py ......... [
> 38%]
> test/test_events.py ...... [
> 39%]
> test/test_examples.py .......................FF.....F.... [
> 47%]
> test/test_exceptions.py . [
> 47%]
> test/test_factory.py ........... [
> 50%]
> test/test_file_message.py ....................... [
> 55%]
> test/test_framers.py ................................................. [
> 66%]
> test/test_interfaces.py ..... [
> 67%]
> test/test_mei_messages.py ........ [
> 69%]
> test/test_other_messages.py ....... [
> 70%]
> test/test_payload.py ......... [
> 72%]
> test/test_pdu.py .... [
> 73%]
> test/test_register_read_messages.py ........... [
> 76%]
> test/test_register_write_messages.py ............ [
> 79%]
> test/test_remote_datastore.py .... [
> 79%]
> test/test_repl_client.py .. [
> 80%]
> test/test_server_asyncio.py ....FE...........FEFEFEFEFE.FE [
> 85%]
> test/test_server_context.py ........... [
> 88%]
> test/test_transaction.py .............................................. [
> 98%]
> test/test_utilities.py ..... [
> 99%]
> test/test_version.py ..
> [100%]
>
> ==================================== ERRORS
> ====================================
> ______ ERROR at teardown of AsyncioServerTest.test_async_start_udp_server
> ______
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_start_udp_server>
>
> async def asyncTearDown(self):
> """Clean up the test environment"""
> if self.server is not None:
> await self.server.server_close()
> self.server = None
> if self.task is not None:
> await asyncio.sleep(0.1)
> if not self.task.cancelled():
> self.task.cancel()
> try:
> > await self.task
> E TypeError: BaseEventLoop.create_datagram_endpoint() got
> an unexpected keyword argument 'reuse_address'
>
> test/test_server_asyncio.py:142: TypeError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ____ ERROR at teardown of AsyncioServerTest.test_async_udp_server_exception
> ____
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_exception>
>
> async def asyncTearDown(self):
> """Clean up the test environment"""
> if self.server is not None:
> await self.server.server_close()
> self.server = None
> if self.task is not None:
> await asyncio.sleep(0.1)
> if not self.task.cancelled():
> self.task.cancel()
> try:
> > await self.task
> E TypeError: BaseEventLoop.create_datagram_endpoint() got
> an unexpected keyword argument 'reuse_address'
>
> test/test_server_asyncio.py:142: TypeError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> __ ERROR at teardown of AsyncioServerTest.test_async_udp_server_receive_data
> ___
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_receive_data>
>
> async def asyncTearDown(self):
> """Clean up the test environment"""
> if self.server is not None:
> await self.server.server_close()
> self.server = None
> if self.task is not None:
> await asyncio.sleep(0.1)
> if not self.task.cancelled():
> self.task.cancel()
> try:
> > await self.task
> E TypeError: BaseEventLoop.create_datagram_endpoint() got
> an unexpected keyword argument 'reuse_address'
>
> test/test_server_asyncio.py:142: TypeError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ____ ERROR at teardown of AsyncioServerTest.test_async_udp_server_roundtrip
> ____
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_roundtrip>
>
> async def asyncTearDown(self):
> """Clean up the test environment"""
> if self.server is not None:
> await self.server.server_close()
> self.server = None
> if self.task is not None:
> await asyncio.sleep(0.1)
> if not self.task.cancelled():
> self.task.cancel()
> try:
> > await self.task
> E TypeError: BaseEventLoop.create_datagram_endpoint() got
> an unexpected keyword argument 'reuse_address'
>
> test/test_server_asyncio.py:142: TypeError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ____ ERROR at teardown of AsyncioServerTest.test_async_udp_server_send_data
> ____
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_send_data>
>
> async def asyncTearDown(self):
> """Clean up the test environment"""
> if self.server is not None:
> await self.server.server_close()
> self.server = None
> if self.task is not None:
> await asyncio.sleep(0.1)
> if not self.task.cancelled():
> self.task.cancel()
> try:
> > await self.task
> E TypeError: BaseEventLoop.create_datagram_endpoint() got
> an unexpected keyword argument 'reuse_address'
>
> test/test_server_asyncio.py:142: TypeError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> _ ERROR at teardown of
> AsyncioServerTest.test_async_udp_server_serve_forever_close _
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_serve_forever_close>
>
> async def asyncTearDown(self):
> """Clean up the test environment"""
> if self.server is not None:
> await self.server.server_close()
> self.server = None
> if self.task is not None:
> await asyncio.sleep(0.1)
> if not self.task.cancelled():
> self.task.cancel()
> try:
> > await self.task
> E TypeError: BaseEventLoop.create_datagram_endpoint() got
> an unexpected keyword argument 'reuse_address'
>
> test/test_server_asyncio.py:142: TypeError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> _ ERROR at teardown of
> AsyncioServerTest.test_async_udp_server_serve_forever_twice _
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_serve_forever_twice>
>
> async def asyncTearDown(self):
> """Clean up the test environment"""
> if self.server is not None:
> await self.server.server_close()
> self.server = None
> if self.task is not None:
> await asyncio.sleep(0.1)
> if not self.task.cancelled():
> self.task.cancel()
> try:
> > await self.task
> E TypeError: BaseEventLoop.create_datagram_endpoint() got
> an unexpected keyword argument 'reuse_address'
>
> test/test_server_asyncio.py:142: TypeError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> =================================== FAILURES
> ===================================
> _ test_exp_async_framer[run_async_basic_calls-udp-ModbusSocketFramer-5024-30]
> __
>
> fut = <Future cancelled>, timeout = 3
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> test_comm = 'udp'
> test_framer = <class 'pymodbus.framer.socket_framer.ModbusSocketFramer'>
> test_port_offset = 30, test_port = 5024, mock_run_server = None
> test_type = <function run_async_basic_calls at 0x7fa5b2c396c0>
>
> @pytest.mark.parametrize("test_port_offset", [30])
> @pytest.mark.parametrize("test_comm, test_framer, test_port",
> TEST_COMMS_FRAMER)
> @pytest.mark.parametrize(
> "test_type",
> [
> None,
> run_async_basic_calls,
> run_async_ext_calls,
> ],
> )
> async def test_exp_async_framer( # pylint: disable=unused-argument
> test_comm,
> test_framer,
> test_port_offset,
> test_port,
> mock_run_server,
> test_type
> ):
> """Test client-server async with different framers and calls."""
> if test_type == run_async_ext_calls and test_framer ==
> ModbusRtuFramer: # pylint: disable=comparison-with-callable
> return
> if test_comm == "serial":
> return
>
> args = Commandline
> args.framer = test_framer
> args.comm = test_comm
> args.port = test_port
> if isinstance(test_port, int):
> args.port += test_port_offset
> > await run_client(test_comm, test_type, args=args)
>
> test/test_examples.py:152:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_examples.py:83: in run_client
> await run_async_client(test_client, modbus_calls=test_type)
> ../../../examples/client_async.py:132: in run_async_client
> await modbus_calls(client)
> ../../../examples/client_async_basic_calls.py:116: in run_async_basic_calls
> await _handle_coils(client)
> ../../../examples/client_async_basic_calls.py:21: in _handle_coils
> rr = await client.read_coils(1, 1, slave=SLAVE)
> pymodbus/client/base.py:292: in execute
> resp = await asyncio.wait_for(req, timeout=self.params.timeout)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled>, timeout = 3
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> INFO root:server_async.py:71 ### Create datastore
> INFO root:server_async.py:150 ### start ASYNC server on port 5054
> ------------------------------ Captured log call
> -------------------------------
> INFO root:client_async.py:52 ### Create client object
> INFO root:client_async.py:128 ### Client starting
> DEBUG pymodbus.client.udp:udp.py:74 Connecting to 127.0.0.1:5054.
> DEBUG pymodbus.client.udp:udp.py:107 Connecting.
> DEBUG pymodbus.client.base:base.py:350 Client connected to modbus server
> INFO pymodbus.client.udp:udp.py:128 Protocol made connection.
> INFO pymodbus.client.udp:udp.py:116 Connected to 127.0.0.1:5054.
> INFO root:client_async_basic_calls.py:20 ### Reading Coil
> DEBUG pymodbus.client.base:base.py:380 send: 0x0 0x1 0x0 0x0 0x0 0x6 0x1
> 0x1 0x0 0x1 0x0 0x1
> DEBUG pymodbus.transaction:transaction.py:516 Adding transaction 1
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ___ test_exp_async_framer[run_async_basic_calls-udp-ModbusRtuFramer-5025-30]
> ___
>
> fut = <Future cancelled>, timeout = 3
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> test_comm = 'udp'
> test_framer = <class 'pymodbus.framer.rtu_framer.ModbusRtuFramer'>
> test_port_offset = 30, test_port = 5025, mock_run_server = None
> test_type = <function run_async_basic_calls at 0x7fa5b2c396c0>
>
> @pytest.mark.parametrize("test_port_offset", [30])
> @pytest.mark.parametrize("test_comm, test_framer, test_port",
> TEST_COMMS_FRAMER)
> @pytest.mark.parametrize(
> "test_type",
> [
> None,
> run_async_basic_calls,
> run_async_ext_calls,
> ],
> )
> async def test_exp_async_framer( # pylint: disable=unused-argument
> test_comm,
> test_framer,
> test_port_offset,
> test_port,
> mock_run_server,
> test_type
> ):
> """Test client-server async with different framers and calls."""
> if test_type == run_async_ext_calls and test_framer ==
> ModbusRtuFramer: # pylint: disable=comparison-with-callable
> return
> if test_comm == "serial":
> return
>
> args = Commandline
> args.framer = test_framer
> args.comm = test_comm
> args.port = test_port
> if isinstance(test_port, int):
> args.port += test_port_offset
> > await run_client(test_comm, test_type, args=args)
>
> test/test_examples.py:152:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_examples.py:83: in run_client
> await run_async_client(test_client, modbus_calls=test_type)
> ../../../examples/client_async.py:132: in run_async_client
> await modbus_calls(client)
> ../../../examples/client_async_basic_calls.py:116: in run_async_basic_calls
> await _handle_coils(client)
> ../../../examples/client_async_basic_calls.py:21: in _handle_coils
> rr = await client.read_coils(1, 1, slave=SLAVE)
> pymodbus/client/base.py:292: in execute
> resp = await asyncio.wait_for(req, timeout=self.params.timeout)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled>, timeout = 3
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> INFO root:server_async.py:71 ### Create datastore
> INFO root:server_async.py:150 ### start ASYNC server on port 5055
> ------------------------------ Captured log call
> -------------------------------
> INFO root:client_async.py:52 ### Create client object
> INFO root:client_async.py:128 ### Client starting
> DEBUG pymodbus.client.udp:udp.py:74 Connecting to 127.0.0.1:5055.
> DEBUG pymodbus.client.udp:udp.py:107 Connecting.
> DEBUG pymodbus.client.base:base.py:350 Client connected to modbus server
> INFO pymodbus.client.udp:udp.py:128 Protocol made connection.
> INFO pymodbus.client.udp:udp.py:116 Connected to 127.0.0.1:5055.
> INFO root:client_async_basic_calls.py:20 ### Reading Coil
> DEBUG pymodbus.client.base:base.py:380 send: 0x1 0x1 0x0 0x1 0x0 0x1 0xac
> 0xa
> DEBUG pymodbus.transaction:transaction.py:516 Adding transaction 1
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> __ test_exp_async_framer[run_async_ext_calls-udp-ModbusSocketFramer-5024-30]
> ___
>
> fut = <Future cancelled>, timeout = 3
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> test_comm = 'udp'
> test_framer = <class 'pymodbus.framer.socket_framer.ModbusSocketFramer'>
> test_port_offset = 30, test_port = 5024, mock_run_server = None
> test_type = <function run_async_ext_calls at 0x7fa5b2c39940>
>
> @pytest.mark.parametrize("test_port_offset", [30])
> @pytest.mark.parametrize("test_comm, test_framer, test_port",
> TEST_COMMS_FRAMER)
> @pytest.mark.parametrize(
> "test_type",
> [
> None,
> run_async_basic_calls,
> run_async_ext_calls,
> ],
> )
> async def test_exp_async_framer( # pylint: disable=unused-argument
> test_comm,
> test_framer,
> test_port_offset,
> test_port,
> mock_run_server,
> test_type
> ):
> """Test client-server async with different framers and calls."""
> if test_type == run_async_ext_calls and test_framer ==
> ModbusRtuFramer: # pylint: disable=comparison-with-callable
> return
> if test_comm == "serial":
> return
>
> args = Commandline
> args.framer = test_framer
> args.comm = test_comm
> args.port = test_port
> if isinstance(test_port, int):
> args.port += test_port_offset
> > await run_client(test_comm, test_type, args=args)
>
> test/test_examples.py:152:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_examples.py:83: in run_client
> await run_async_client(test_client, modbus_calls=test_type)
> ../../../examples/client_async.py:132: in run_async_client
> await modbus_calls(client)
> ../../../examples/client_async_extended_calls.py:166: in run_async_ext_calls
> await _execute_information_requests(client)
> ../../../examples/client_async_extended_calls.py:63: in
> _execute_information_requests
> rr = await client.execute(ReadDeviceInformationRequest(unit=UNIT))
> pymodbus/client/base.py:292: in execute
> resp = await asyncio.wait_for(req, timeout=self.params.timeout)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled>, timeout = 3
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> INFO root:server_async.py:71 ### Create datastore
> INFO root:server_async.py:150 ### start ASYNC server on port 5054
> ------------------------------ Captured log call
> -------------------------------
> INFO root:client_async.py:52 ### Create client object
> INFO root:client_async.py:128 ### Client starting
> DEBUG pymodbus.client.udp:udp.py:74 Connecting to 127.0.0.1:5054.
> DEBUG pymodbus.client.udp:udp.py:107 Connecting.
> DEBUG pymodbus.client.base:base.py:350 Client connected to modbus server
> INFO pymodbus.client.udp:udp.py:128 Protocol made connection.
> INFO pymodbus.client.udp:udp.py:116 Connected to 127.0.0.1:5054.
> INFO root:client_async_extended_calls.py:62 ### Running
> ReadDeviceInformationRequest
> DEBUG pymodbus.client.base:base.py:380 send: 0x0 0x1 0x0 0x0 0x0 0x5 0x1
> 0x2b 0xe 0x1 0x0
> DEBUG pymodbus.transaction:transaction.py:516 Adding transaction 1
> ---------------------------- Captured log teardown
> -----------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ________________ AsyncioServerTest.test_async_start_udp_server
> _________________
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_start_udp_server>
>
> async def test_async_start_udp_server(self):
> """Test that the modbus udp asyncio server starts correctly"""
> > await self.start_server(do_udp=True, do_ident=True)
>
> test/test_server_asyncio.py:331:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_server_asyncio.py:181: in start_server
> await asyncio.wait_for(self.server.serving, timeout=0.1)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ______________ AsyncioServerTest.test_async_udp_server_exception
> _______________
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_exception>
>
> async def test_async_udp_server_exception(self):
> """Test sending garbage data on a TCP socket should drop the
> connection"""
> BasicClient.dataTo = b"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"
> BasicClient.connected = self.loop.create_future()
> BasicClient.done = self.loop.create_future()
> > await self.start_server(do_udp=True)
>
> test/test_server_asyncio.py:414:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_server_asyncio.py:181: in start_server
> await asyncio.wait_for(self.server.serving, timeout=0.1)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> _____________ AsyncioServerTest.test_async_udp_server_receive_data
> _____________
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_receive_data>
>
> @pytest.mark.skifif(pytest.IS_WINDOWS, reason="Windows have a timeout
> problem.")
> async def test_async_udp_server_receive_data(self):
> """Test that the sending data on datagram socket gets data pushed to
> framer"""
> > await self.start_server(do_udp=True)
>
> test/test_server_asyncio.py:363:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_server_asyncio.py:181: in start_server
> await asyncio.wait_for(self.server.serving, timeout=0.1)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ______________ AsyncioServerTest.test_async_udp_server_roundtrip
> _______________
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_roundtrip>
>
> async def test_async_udp_server_roundtrip(self):
> """Test sending and receiving data on udp socket"""
> expected_response = b"\x01\x00\x00\x00\x00\x05\x01\x03\x02\x00\x11"
> # value of 17 as per context
> BasicClient.dataTo = TEST_DATA # unit 1, read register
> BasicClient.done = self.loop.create_future()
> > await self.start_server(do_udp=True)
>
> test/test_server_asyncio.py:398:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_server_asyncio.py:181: in start_server
> await asyncio.wait_for(self.server.serving, timeout=0.1)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> ______________ AsyncioServerTest.test_async_udp_server_send_data
> _______________
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_send_data>
>
> async def test_async_udp_server_send_data(self):
> """Test that the modbus udp asyncio server correctly sends data
> outbound"""
> BasicClient.dataTo =
> b"x\01\x00\x00\x00\x00\x06\x01\x03\x00\x00\x00\x19"
> > await self.start_server(do_udp=True)
>
> test/test_server_asyncio.py:377:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_server_asyncio.py:181: in start_server
> await asyncio.wait_for(self.server.serving, timeout=0.1)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> _________ AsyncioServerTest.test_async_udp_server_serve_forever_close
> __________
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_serve_forever_close>
>
> async def test_async_udp_server_serve_forever_close(self):
> """Test StarAsyncUdpServer serve_forever() method"""
> > await self.start_server(do_udp=True)
>
> test/test_server_asyncio.py:346:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_server_asyncio.py:181: in start_server
> await asyncio.wait_for(self.server.serving, timeout=0.1)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> _________ AsyncioServerTest.test_async_udp_server_serve_forever_twice
> __________
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> > return fut.result()
> E asyncio.exceptions.CancelledError
>
> /usr/lib/python3.11/asyncio/tasks.py:490: CancelledError
>
> The above exception was the direct cause of the following exception:
>
> self = <test.test_server_asyncio.AsyncioServerTest
> testMethod=test_async_udp_server_serve_forever_twice>
>
> async def test_async_udp_server_serve_forever_twice(self):
> """Call on serve_forever() twice should result in a runtime error"""
> > await self.start_server(do_udp=True, do_ident=True)
>
> test/test_server_asyncio.py:356:
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
> test/test_server_asyncio.py:181: in start_server
> await asyncio.wait_for(self.server.serving, timeout=0.1)
> _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
> _
>
> fut = <Future cancelled created at
> /usr/lib/python3.11/asyncio/base_events.py:427>
> timeout = 0.1
>
> async def wait_for(fut, timeout):
> """Wait for the single Future or coroutine to complete, with timeout.
>
> Coroutine will be wrapped in Task.
>
> Returns result of the Future or coroutine. When a timeout occurs,
> it cancels the task and raises TimeoutError. To avoid the task
> cancellation, wrap it in shield().
>
> If the wait is cancelled, the task is also cancelled.
>
> This function is a coroutine.
> """
> loop = events.get_running_loop()
>
> if timeout is None:
> return await fut
>
> if timeout <= 0:
> fut = ensure_future(fut, loop=loop)
>
> if fut.done():
> return fut.result()
>
> await _cancel_and_wait(fut, loop=loop)
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> raise exceptions.TimeoutError() from exc
>
> waiter = loop.create_future()
> timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
> cb = functools.partial(_release_waiter, waiter)
>
> fut = ensure_future(fut, loop=loop)
> fut.add_done_callback(cb)
>
> try:
> # wait until the future completes or the timeout
> try:
> await waiter
> except exceptions.CancelledError:
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> raise
>
> if fut.done():
> return fut.result()
> else:
> fut.remove_done_callback(cb)
> # We must ensure that the task is not running
> # after wait_for() returns.
> # See https://bugs.python.org/issue32751
> await _cancel_and_wait(fut, loop=loop)
> # In case task cancellation failed with some
> # exception, we should re-raise it
> # See https://bugs.python.org/issue40607
> try:
> return fut.result()
> except exceptions.CancelledError as exc:
> > raise exceptions.TimeoutError() from exc
> E TimeoutError
>
> /usr/lib/python3.11/asyncio/tasks.py:492: TimeoutError
> ------------------------------ Captured log setup
> ------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ------------------------------ Captured log call
> -------------------------------
> DEBUG asyncio:selector_events.py:54 Using selector: EpollSelector
> ERROR asyncio:base_events.py:1765 Exception in callback
> AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> handle: <Handle AsyncioServerTest.handle_task(<Task finishe.../tasks.py:374>)
> created at /usr/lib/python3.11/asyncio/events.py:80>
> source_traceback: Object created at (most recent call last):
> File "/usr/lib/python3.11/unittest/case.py", line 623, in run
> self._callTestMethod(testMethod)
> File "/usr/lib/python3.11/unittest/async_case.py", line 90, in
> _callTestMethod
> if self._callMaybeAsync(method) is not None:
> File "/usr/lib/python3.11/unittest/async_case.py", line 112, in
> _callMaybeAsync
> return self._asyncioRunner.run(
> File "/usr/lib/python3.11/asyncio/runners.py", line 118, in run
> return self._loop.run_until_complete(task)
> File "/usr/lib/python3.11/asyncio/base_events.py", line 640, in
> run_until_complete
> self.run_forever()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 607, in run_forever
> self._run_once()
> File "/usr/lib/python3.11/asyncio/base_events.py", line 1911, in _run_once
> handle._run()
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> Traceback (most recent call last):
> File "/usr/lib/python3.11/asyncio/events.py", line 80, in _run
> self._context.run(self._callback, *self._args)
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/test/test_server_asyncio.py",
> line 155, in handle_task
> result = result.result()
> ^^^^^^^^^^^^^^^
> File
> "/<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build/pymodbus/server/async_io.py",
> line 729, in serve_forever
> self.protocol, self.endpoint = await self.loop.create_datagram_endpoint(
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> TypeError: BaseEventLoop.create_datagram_endpoint() got an unexpected keyword
> argument 'reuse_address'
> DEBUG asyncio:base_events.py:676 Close <_UnixSelectorEventLoop
> running=False closed=False debug=True>
> =========================== short test summary info
> ============================
> FAILED
> test/test_examples.py::test_exp_async_framer[run_async_basic_calls-udp-ModbusSocketFramer-5024-30]
> FAILED
> test/test_examples.py::test_exp_async_framer[run_async_basic_calls-udp-ModbusRtuFramer-5025-30]
> FAILED
> test/test_examples.py::test_exp_async_framer[run_async_ext_calls-udp-ModbusSocketFramer-5024-30]
> FAILED
> test/test_server_asyncio.py::AsyncioServerTest::test_async_start_udp_server
> FAILED
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_exception
> FAILED
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_receive_data
> FAILED
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_roundtrip
> FAILED
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_send_data
> FAILED
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_serve_forever_close
> FAILED
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_serve_forever_twice
> ERROR
> test/test_server_asyncio.py::AsyncioServerTest::test_async_start_udp_server
> ERROR
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_exception
> ERROR
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_receive_data
> ERROR
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_roundtrip
> ERROR
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_send_data
> ERROR
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_serve_forever_close
> ERROR
> test/test_server_asyncio.py::AsyncioServerTest::test_async_udp_server_serve_forever_twice
> ============= 10 failed, 433 passed, 7 errors in 65.04s (0:01:05)
> ==============
> E: pybuild pybuild:388: test: plugin distutils failed with: exit code=1: cd
> /<<PKGBUILDDIR>>/.pybuild/cpython3_3.11_pymodbus/build; python3.11 -m pytest
> test
> dh_auto_test: error: pybuild --test --test-pytest -i python{version} -p 3.11
> returned exit code 13
The full build log is available from:
http://qa-logs.debian.net/2023/01/13/pymodbus_3.0.0-5_unstable.log
All bugs filed during this archive rebuild are listed at:
https://bugs.debian.org/cgi-bin/pkgreport.cgi?tag=ftbfs-20230113;[email protected]
or:
https://udd.debian.org/bugs/?release=na&merged=ign&fnewerval=7&flastmodval=7&fusertag=only&fusertagtag=ftbfs-20230113&[email protected]&allbugs=1&cseverity=1&ctags=1&caffected=1#results
A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!
If you reassign this bug to another package, please mark it as 'affects'-ing
this package. See https://www.debian.org/Bugs/server-control#affects
If you fail to reproduce this, please provide a build log and diff it with mine
so that we can identify if something relevant changed in the meantime.
--- End Message ---
