python-pyvlx fails to build with Python 3.11.0a4.

=================================== FAILURES ===================================
_________________ TestFrameActivateSceneConfirmation.test_str __________________

self = <frame_activate_scene_cfm_test.TestFrameActivateSceneConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameActivateSceneConfirmation."""
        frame = FrameActivateSceneConfirmation(
            session_id=1000, status=ActivateSceneConfirmationStatus.ACCEPTED
        )
>       self.assertEqual(
            str(frame),
            '<FrameActivateSceneConfirmation session_id="1000" status="ActivateSceneConfirmationStatus.ACCEPTED"/>',
        )
E       AssertionError: '<Fra[35 chars]_id="1000" status="ACCEPTED"/>' != '<Fra[35 chars]_id="1000" status="ActivateSceneConfirmationStatus.ACCEPTED"/>'
E       - <FrameActivateSceneConfirmation session_id="1000" status="ACCEPTED"/>
E       + <FrameActivateSceneConfirmation session_id="1000" status="ActivateSceneConfirmationStatus.ACCEPTED"/>
E       ?                                                           ++++++++++++++++++++++++++++++++

test/frame_activate_scene_cfm_test.py:43: AssertionError
____________________ TestFrameActivateSceneRequest.test_str ____________________

self = <frame_activate_scene_req_test.TestFrameActivateSceneRequest testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameActivateSceneRequest."""
        frame = FrameActivateSceneRequest(
            scene_id=4, session_id=1000, velocity=Velocity.FAST
        )
>       self.assertEqual(
            str(frame),
            '<FrameActivateSceneRequest scene_id="4" session_id="1000" '
            'originator="Originator.USER" velocity="Velocity.FAST"/>',
        )
E       AssertionError: '<Fra[47 chars]"1000" originator="USER" velocity="FAST"/>' != '<Fra[47 chars]"1000" originator="Originator.USER" velocity="Velocity.FAST"/>'
E       - <FrameActivateSceneRequest scene_id="4" session_id="1000" originator="USER" velocity="FAST"/>
E       + <FrameActivateSceneRequest scene_id="4" session_id="1000" originator="Originator.USER" velocity="Velocity.FAST"/>
E       ?                                                                       +++++++++++                +++++++++

test/frame_activate_scene_req_test.py:41: AssertionError
__________________ TestFrameCommandSendConfirmation.test_str ___________________

self = <frame_command_send_cfm_test.TestFrameCommandSendConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameCommandSendConfirmation."""
        frame = FrameCommandSendConfirmation(
            session_id=1000, status=CommandSendConfirmationStatus.ACCEPTED
        )
>       self.assertEqual(
            str(frame),
            '<FrameCommandSendConfirmation session_id="1000" status="CommandSendConfirmationStatus.ACCEPTED"/>',
        )
E       AssertionError: '<Fra[31 chars]on_id="1000" status="ACCEPTED"/>' != '<Fra[31 chars]on_id="1000" status="CommandSendConfirmationStatus.ACCEPTED"/>'
E       - <FrameCommandSendConfirmation session_id="1000" status="ACCEPTED"/>
E       + <FrameCommandSendConfirmation session_id="1000" status="CommandSendConfirmationStatus.ACCEPTED"/>
E       ?                                                         ++++++++++++++++++++++++++++++

test/frame_command_send_cfm_test.py:40: AssertionError
_____________________ TestFrameCommandSendRequest.test_str _____________________

self = <frame_command_send_req_test.TestFrameCommandSendRequest testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameCommandSendRequest."""
        functional_para = {"fp3": Position(position=12345)}
        functional_parameter = {}
        for i in range(1, 17):
            key = "fp%s" % (i)
            if key in functional_para:
                functional_parameter[key] = functional_para[key]
            else:
                functional_parameter[key] = bytes(2)
        frame = FrameCommandSendRequest(
            node_ids=[1, 2, 3],
            parameter=Position(position=12345),
            **functional_parameter,
            session_id=1000,
            originator=Originator.RAIN
        )
>       self.assertEqual(
            str(frame),
            '<FrameCommandSendRequest node_ids="[1, 2, 3]" parameter="24 %" '
            'functional_parameter="fp1: 0 %, fp2: 0 %, fp3: 24 %, fp4: 0 %, fp5: 0 %, fp6: 0 %, fp7: 0 %, '
            'fp8: 0 %, fp9: 0 %, fp10: 0 %, fp11: 0 %, fp12: 0 %, fp13: 0 %, fp14: 0 %, fp15: 0 %, fp16: 0 %, " '
            'session_id="1000" originator="Originator.RAIN"/>',
        )
E       AssertionError: '<Fra[237 chars] fp16: 0 %, " session_id="1000" originator="RAIN"/>' != '<Fra[237 chars] fp16: 0 %, " session_id="1000" originator="Originator.RAIN"/>'
E       Diff is 901 characters long. Set self.maxDiff to None to see it.

test/frame_command_send_req_test.py:59: AssertionError
________________________ TestFrameNodeDiscover.test_str ________________________

self = <frame_discover_nodes_req_test.TestFrameNodeDiscover testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameDiscoverNodesRequest."""
        frame = FrameDiscoverNodesRequest(NodeType.LIGHT)
>       self.assertEqual(
            str(frame), '<FrameDiscoverNodesRequest node_type="NodeType.LIGHT"/>'
        )
E       AssertionError: '<FrameDiscoverNodesRequest node_type="LIGHT"/>' != '<FrameDiscoverNodesRequest node_type="NodeType.LIGHT"/>'
E       - <FrameDiscoverNodesRequest node_type="LIGHT"/>
E       + <FrameDiscoverNodesRequest node_type="NodeType.LIGHT"/>
E       ?                                       +++++++++

test/frame_discover_nodes_req_test.py:33: AssertionError
________________________ TestErrorNotification.test_str ________________________

self = <frame_error_test.TestErrorNotification testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameErrorNotification."""
        frame = FrameErrorNotification(error_type=ErrorType.ErrorOnFrameStructure)
>       self.assertEqual(
            str(frame),
            '<FrameErrorNotification error_type="ErrorType.ErrorOnFrameStructure"/>',
        )
E       AssertionError: '<FrameErrorNotification error_type="ErrorOnFrameStructure"/>' != '<FrameErrorNotification error_type="ErrorType.ErrorOnFrameStructure"/>'
E       - <FrameErrorNotification error_type="ErrorOnFrameStructure"/>
E       + <FrameErrorNotification error_type="ErrorType.ErrorOnFrameStructure"/>
E       ?                                     ++++++++++

test/frame_error_test.py:27: AssertionError
_____________ TestFrameGetAllNodesInformationConfirmation.test_str _____________

self = <frame_get_all_nodes_information_cfm_test.TestFrameGetAllNodesInformationConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameGetAllNodesInformationConfirmation."""
        frame = FrameGetAllNodesInformationConfirmation(number_of_nodes=23)
>       self.assertEqual(
            str(frame),
            '<FrameGetAllNodesInformationConfirmation status="AllNodesInformationStatus.OK" number_of_nodes="23"/>',
        )
E       AssertionError: '<Fra[35 chars]n status="OK" number_of_nodes="23"/>' != '<Fra[35 chars]n status="AllNodesInformationStatus.OK" number_of_nodes="23"/>'
E       - <FrameGetAllNodesInformationConfirmation status="OK" number_of_nodes="23"/>
E       + <FrameGetAllNodesInformationConfirmation status="AllNodesInformationStatus.OK" number_of_nodes="23"/>
E       ?                                                  ++++++++++++++++++++++++++

test/frame_get_all_nodes_information_cfm_test.py:27: AssertionError
_____________ TestFrameGetAllNodesInformationNotification.test_str _____________

self = <frame_get_all_nodes_information_ntf_test.TestFrameGetAllNodesInformationNotification testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameGetAllNodesInformationNotification."""
        frame = frame_from_raw(self.EXAMPLE_FRAME)
        test_ts = datetime.fromtimestamp(50528771).strftime("%Y-%m-%d %H:%M:%S")
>       self.assertEqual(
            str(frame),
            '<FrameGetAllNodesInformationNotification node_id="23" order="1234" placement="2" '
            'name="Fnord23" velocity="Velocity.SILENT" node_type="NodeTypeWithSubtype.INTERIOR_VENETIAN_BLIND" '
            'product_group="23" product_type="13" node_variation="NodeVariation.TOPHUNG" '
            'power_mode="1" build_number="7" serial_number="01:02:03:04:05:06:06:08" state="1" '
            'current_position="0x000C" target="0x007B" current_position_fp1="0x04D2" '
            'current_position_fp2="0x0929" current_position_fp3="0x0D80" current_position_fp4="0x11D7" '
            'remaining_time="1" time="{}" '
            'alias_array="3031=3233, 3435=3637, 3839=3031, 3233=3435, 3637=3839"/>'.format(
                test_ts
            ),
        )
E       AssertionError: '<Fra[97 chars]ity="SILENT" node_type="INTERIOR_VENETIAN_BLIN[420 chars]9"/>' != '<Fra[97 chars]ity="Velocity.SILENT" node_type="NodeTypeWithS[463 chars]9"/>'
E       Diff is 1441 characters long. Set self.maxDiff to None to see it.

test/frame_get_all_nodes_information_ntf_test.py:90: AssertionError
____________________ TestFrameGetLimitationStatus.test_str _____________________

self = <frame_get_limitation_status_req_test.TestFrameGetLimitationStatus testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameGetLimitationStatus."""
        frame = FrameGetLimitationStatus(node_ids=[1], session_id=1, limitation_type=LimitationType.MIN_LIMITATION)
>       self.assertEqual(str(frame), '<FrameGetLimitationStatus node_ids="[1]" session_id="1" originator="Originator.USER" />')
E       AssertionError: '<Fra[21 chars] node_ids="[1]" session_id="1" originator="USER" />' != '<Fra[21 chars] node_ids="[1]" session_id="1" originator="Originator.USER" />'
E       - <FrameGetLimitationStatus node_ids="[1]" session_id="1" originator="USER" />
E       + <FrameGetLimitationStatus node_ids="[1]" session_id="1" originator="Originator.USER" />
E       ?                                                                     +++++++++++

test/frame_get_limitation_status_req_test.py:33: AssertionError
________________ TestFrameGetNetworkSetupConfirmation.test_str _________________

self = <frame_get_network_setup_cfm_test.TestFrameGetNetworkSetupConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameGetNetworkSetupConfirmation."""
        frame = FrameGetNetworkSetupConfirmation(
            ipaddress=b'\xc0\xa8\r\xe3', netmask=b'\xff\xff\xff\x00',
            gateway=b'\xc0\xa8\r\x01', dhcp=DHCPParameter.DISABLE)
>       self.assertEqual(
            str(frame),
            '<FrameGetNetworkSetupConfirmation ipaddress="192.168.13.227" '
            'netmask="255.255.255.0" gateway="192.168.13.1" dhcp="DHCPParameter.DISABLE"/>',
        )
E       AssertionError: '<Fra[72 chars]5.255.0" gateway="192.168.13.1" dhcp="DISABLE"/>' != '<Fra[72 chars]5.255.0" gateway="192.168.13.1" dhcp="DHCPParameter.DISABLE"/>'
E       - <FrameGetNetworkSetupConfirmation ipaddress="192.168.13.227" netmask="255.255.255.0" gateway="192.168.13.1" dhcp="DISABLE"/>
E       + <FrameGetNetworkSetupConfirmation ipaddress="192.168.13.227" netmask="255.255.255.0" gateway="192.168.13.1" dhcp="DHCPParameter.DISABLE"/>
E       ?                                                                                                                   ++++++++++++++

test/frame_get_network_setup_cfm_test.py:36: AssertionError
_______________ TestFrameGetNodeInformationConfirmation.test_str _______________

self = <frame_get_node_information_cfm_test.TestFrameGetNodeInformationConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameGetNodeInformationConfirmation."""
        frame = FrameGetNodeInformationConfirmation(node_id=23)
>       self.assertEqual(
            str(frame),
            '<FrameGetNodeInformationConfirmation node_id="23" status="NodeInformationStatus.OK"/>',
        )
E       AssertionError: '<Fra[19 chars]nConfirmation node_id="23" status="OK"/>' != '<Fra[19 chars]nConfirmation node_id="23" status="NodeInformationStatus.OK"/>'
E       - <FrameGetNodeInformationConfirmation node_id="23" status="OK"/>
E       + <FrameGetNodeInformationConfirmation node_id="23" status="NodeInformationStatus.OK"/>
E       ?                                                           ++++++++++++++++++++++

test/frame_get_node_information_cfm_test.py:27: AssertionError
_______________ TestFrameGetNodeInformationNotification.test_str _______________

self = <frame_get_node_information_ntf_test.TestFrameGetNodeInformationNotification testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameGetNodeInformationNotification."""
        frame = frame_from_raw(self.EXAMPLE_FRAME)
        test_ts = datetime.fromtimestamp(50528771).strftime("%Y-%m-%d %H:%M:%S")
>       self.assertEqual(
            str(frame),
            '<FrameGetNodeInformationNotification node_id="23" order="1234" placement="2" '
            'name="Fnord23" velocity="Velocity.SILENT" node_type="NodeTypeWithSubtype.INTERIOR_VENETIAN_BLIND" '
            'product_group="23" product_type="13" node_variation="NodeVariation.TOPHUNG" '
            'power_mode="1" build_number="7" serial_number="01:02:03:04:05:06:06:08" state="1" '
            'current_position="0x000C" target="0x007B" current_position_fp1="0x04D2" '
            'current_position_fp2="0x0929" current_position_fp3="0x0D80" current_position_fp4="0x11D7" '
            'remaining_time="1" time="{}" '
            'alias_array="3031=3233, 3435=3637, 3839=3031, 3233=3435, 3637=3839"/>'.format(
                test_ts
            ),
        )
E       AssertionError: '<Fra[93 chars]ity="SILENT" node_type="INTERIOR_VENETIAN_BLIN[420 chars]9"/>' != '<Fra[93 chars]ity="Velocity.SILENT" node_type="NodeTypeWithS[463 chars]9"/>'
E       Diff is 1429 characters long. Set self.maxDiff to None to see it.

test/frame_get_node_information_ntf_test.py:90: AssertionError
____________________ TestFrameGetStateConfirmation.test_str ____________________

self = <frame_get_state_cfm_test.TestFrameGetStateConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameGetStateConfirmation."""
        frame = FrameGetStateConfirmation()
        frame.gateway_state = GatewayState.BEACON_MODE_NOT_CONFIGURED
        frame.gateway_sub_state = GatewaySubState.PERFORMING_TASK_COMMAND
>       self.assertEqual(
            str(frame),
            "<FrameGetStateConfirmation "
            'gateway_state="GatewayState.BEACON_MODE_NOT_CONFIGURED" '
            'gateway_sub_state="GatewaySubState.PERFORMING_TASK_COMMAND"/>',
        )
E       AssertionError: '<Fra[33 chars]ate="BEACON_MODE_NOT_CONFIGURED" gateway_sub_s[28 chars]D"/>' != '<Fra[33 chars]ate="GatewayState.BEACON_MODE_NOT_CONFIGURED" [57 chars]D"/>'
E       - <FrameGetStateConfirmation gateway_state="BEACON_MODE_NOT_CONFIGURED" gateway_sub_state="PERFORMING_TASK_COMMAND"/>
E       + <FrameGetStateConfirmation gateway_state="GatewayState.BEACON_MODE_NOT_CONFIGURED" gateway_sub_state="GatewaySubState.PERFORMING_TASK_COMMAND"/>
E       ?                                           +++++++++++++                                               ++++++++++++++++

test/frame_get_state_cfm_test.py:37: AssertionError
________________ TestFrameLeaveLearnStateConfirmation.test_str _________________

self = <frame_leave_learn_state_cfm_test.TestFrameLeaveLearnStateConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameLeaveLearnStateConfirmation."""
        frame = FrameLeaveLearnStateConfirmation()
>       self.assertEqual(str(frame), '<FrameLeaveLearnStateConfirmation status="LeaveLearnStateConfirmationStatus.FAILED"/>')
E       AssertionError: '<Fra[19 chars]nfirmation status="FAILED"/>' != '<Fra[19 chars]nfirmation status="LeaveLearnStateConfirmationStatus.FAILED"/>'
E       - <FrameLeaveLearnStateConfirmation status="FAILED"/>
E       + <FrameLeaveLearnStateConfirmation status="LeaveLearnStateConfirmationStatus.FAILED"/>
E       ?                                           ++++++++++++++++++++++++++++++++++

test/frame_leave_learn_state_cfm_test.py:28: AssertionError
_____________ TestFrameNodeInformationChangedNotification.test_str _____________

self = <frame_node_information_changed_ntf_test.TestFrameNodeInformationChangedNotification testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameNodeInformationChangedNotification."""
        frame = frame_from_raw(self.EXAMPLE_FRAME)
>       self.assertEqual(
            str(frame),
            '<FrameNodeInformationChangedNotification node_id="23" name="Fnord23" '
            'order="1234" placement="2" node_variation="NodeVariation.TOPHUNG"/>',
        )
E       AssertionError: '<Fra[70 chars]="1234" placement="2" node_variation="TOPHUNG"/>' != '<Fra[70 chars]="1234" placement="2" node_variation="NodeVariation.TOPHUNG"/>'
E       - <FrameNodeInformationChangedNotification node_id="23" name="Fnord23" order="1234" placement="2" node_variation="TOPHUNG"/>
E       + <FrameNodeInformationChangedNotification node_id="23" name="Fnord23" order="1234" placement="2" node_variation="NodeVariation.TOPHUNG"/>
E       ?                                                                                                                 ++++++++++++++

test/frame_node_information_changed_ntf_test.py:45: AssertionError
_________________ TestFramePasswordChangeConfirmation.test_str _________________

self = <frame_password_change_cfm_test.TestFramePasswordChangeConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FramePasswordChangeConfirmation."""
        frame = FramePasswordChangeConfirmation()
>       self.assertEqual(
            str(frame),
            '<FramePasswordChangeConfirmation status="PasswordChangeConfirmationStatus.SUCCESSFUL"/>',
        )
E       AssertionError: '<Fra[21 chars]rmation status="SUCCESSFUL"/>' != '<Fra[21 chars]rmation status="PasswordChangeConfirmationStatus.SUCCESSFUL"/>'
E       - <FramePasswordChangeConfirmation status="SUCCESSFUL"/>
E       + <FramePasswordChangeConfirmation status="PasswordChangeConfirmationStatus.SUCCESSFUL"/>
E       ?                                          +++++++++++++++++++++++++++++++++

test/frame_password_change_cfm_test.py:35: AssertionError
_________________ TestFramePasswordEnterConfirmation.test_str __________________

self = <frame_password_enter_cfm_test.TestFramePasswordEnterConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FramePasswordEnterConfirmation."""
        frame = FramePasswordEnterConfirmation()
>       self.assertEqual(
            str(frame),
            '<FramePasswordEnterConfirmation status="PasswordEnterConfirmationStatus.SUCCESSFUL"/>',
        )
E       AssertionError: '<Fra[19 chars]irmation status="SUCCESSFUL"/>' != '<Fra[19 chars]irmation status="PasswordEnterConfirmationStatus.SUCCESSFUL"/>'
E       - <FramePasswordEnterConfirmation status="SUCCESSFUL"/>
E       + <FramePasswordEnterConfirmation status="PasswordEnterConfirmationStatus.SUCCESSFUL"/>
E       ?                                         ++++++++++++++++++++++++++++++++

test/frame_password_enter_cfm_test.py:35: AssertionError
__________________ TestFrameSetNodeNameConfirmation.test_str ___________________

self = <frame_set_node_name_cfm_test.TestFrameSetNodeNameConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameSetNodeNameConfirmation."""
        frame = FrameSetNodeNameConfirmation(node_id=23)
>       self.assertEqual(
            str(frame),
            '<FrameSetNodeNameConfirmation node_id="23" status="SetNodeNameConfirmationStatus.OK"/>',
        )
E       AssertionError: '<Fra[20 chars]ation node_id="23" status="OK"/>' != '<Fra[20 chars]ation node_id="23" status="SetNodeNameConfirmationStatus.OK"/>'
E       - <FrameSetNodeNameConfirmation node_id="23" status="OK"/>
E       + <FrameSetNodeNameConfirmation node_id="23" status="SetNodeNameConfirmationStatus.OK"/>
E       ?                                                    ++++++++++++++++++++++++++++++

test/frame_set_node_name_cfm_test.py:39: AssertionError
____________________ TestFrameStatusRequestRequest.test_str ____________________

self = <frame_status_request_test.TestFrameStatusRequestRequest testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameStatusRequestRequest."""
        frame = FrameStatusRequestRequest(node_ids=[1, 2], session_id=0xAB)
>       self.assertEqual(str(frame), "<FrameStatusRequestRequest session_id=\"171\" node_ids=\"[1, 2]\" "
                                     "status_type=\"StatusType.REQUEST_CURRENT_POSITION\" fpi1=\"254\" fpi2=\"0\"/>")
E       AssertionError: '<Fra[66 chars]ype="REQUEST_CURRENT_POSITION" fpi1="254" fpi2="0"/>' != '<Fra[66 chars]ype="StatusType.REQUEST_CURRENT_POSITION" fpi1[13 chars]0"/>'
E       - <FrameStatusRequestRequest session_id="171" node_ids="[1, 2]" status_type="REQUEST_CURRENT_POSITION" fpi1="254" fpi2="0"/>
E       + <FrameStatusRequestRequest session_id="171" node_ids="[1, 2]" status_type="StatusType.REQUEST_CURRENT_POSITION" fpi1="254" fpi2="0"/>
E       ?                                                                            +++++++++++

test/frame_status_request_test.py:32: AssertionError
_________________ TestFrameStatusRequestConfirmation.test_str __________________

self = <frame_status_request_test.TestFrameStatusRequestConfirmation testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameStatusRequestConfirmation."""
        frame = FrameStatusRequestConfirmation(session_id=0xAB, status=StatusRequestStatus.ACCEPTED)
>       self.assertEqual(str(frame),
                         "<FrameStatusRequestConfirmation session_id=\"171\" status=\"StatusRequestStatus.ACCEPTED\"/>")
E       AssertionError: '<Fra[22 chars]ation session_id="171" status="ACCEPTED"/>' != '<Fra[22 chars]ation session_id="171" status="StatusRequestStatus.ACCEPTED"/>'
E       - <FrameStatusRequestConfirmation session_id="171" status="ACCEPTED"/>
E       + <FrameStatusRequestConfirmation session_id="171" status="StatusRequestStatus.ACCEPTED"/>
E       ?                                                          ++++++++++++++++++++

test/frame_status_request_test.py:56: AssertionError
_________________ TestFrameStatusRequestNotification.test_str __________________

self = <frame_status_request_test.TestFrameStatusRequestNotification testMethod=test_str>

    def test_str(self):
        """Test string representation of FrameStatusRequestNotification."""
        frame = FrameStatusRequestNotification()
>       self.assertEqual(str(frame), "<FrameStatusRequestNotification session_id=\"0\" "
                                     "status_id=\"0\" node_id=\"0\" run_status=\"RunStatus.EXECUTION_COMPLETED\" "
                                     "status_reply=\"StatusReply.UNKNOWN_STATUS_REPLY\" "
                                     "status_type=\"StatusType.REQUEST_TARGET_POSITION\" status_count=\"0\" "
                                     "parameter_data=\"\"/>")
E       AssertionError: '<Fra[76 chars]tus="EXECUTION_COMPLETED" status_reply="UNKNOW[86 chars]""/>' != '<Fra[76 chars]tus="RunStatus.EXECUTION_COMPLETED" status_rep[119 chars]""/>'
E       Diff is 663 characters long. Set self.maxDiff to None to see it.

test/frame_status_request_test.py:85: AssertionError
=============================== warnings summary ===============================
test/config_test.py: 7 warnings
test/get_limitation_test.py: 10 warnings
test/lightening_device_test.py: 3 warnings
test/node_helper_test.py: 12 warnings
test/nodes_test.py: 9 warnings
test/opening_device_test.py: 7 warnings
test/scene_test.py: 2 warnings
test/scenes_test.py: 7 warnings
  /builddir/build/BUILDROOT/python-pyvlx-0.2.20-1.fc36.x86_64/usr/lib/python3.11/site-packages/pyvlx/pyvlx.py:27: DeprecationWarning: There is no current event loop
    self.loop = loop or asyncio.get_event_loop()

-- Docs: https://docs.pytest.org/en/stable/warnings.html
=========================== short test summary info ============================
FAILED test/frame_activate_scene_cfm_test.py::TestFrameActivateSceneConfirmation::test_str
FAILED test/frame_activate_scene_req_test.py::TestFrameActivateSceneRequest::test_str
FAILED test/frame_command_send_cfm_test.py::TestFrameCommandSendConfirmation::test_str
FAILED test/frame_command_send_req_test.py::TestFrameCommandSendRequest::test_str
FAILED test/frame_discover_nodes_req_test.py::TestFrameNodeDiscover::test_str
FAILED test/frame_error_test.py::TestErrorNotification::test_str - AssertionE...
FAILED test/frame_get_all_nodes_information_cfm_test.py::TestFrameGetAllNodesInformationConfirmation::test_str
FAILED test/frame_get_all_nodes_information_ntf_test.py::TestFrameGetAllNodesInformationNotification::test_str
FAILED test/frame_get_limitation_status_req_test.py::TestFrameGetLimitationStatus::test_str
FAILED test/frame_get_network_setup_cfm_test.py::TestFrameGetNetworkSetupConfirmation::test_str
FAILED test/frame_get_node_information_cfm_test.py::TestFrameGetNodeInformationConfirmation::test_str
FAILED test/frame_get_node_information_ntf_test.py::TestFrameGetNodeInformationNotification::test_str
FAILED test/frame_get_state_cfm_test.py::TestFrameGetStateConfirmation::test_str
FAILED test/frame_leave_learn_state_cfm_test.py::TestFrameLeaveLearnStateConfirmation::test_str
FAILED test/frame_node_information_changed_ntf_test.py::TestFrameNodeInformationChangedNotification::test_str
FAILED test/frame_password_change_cfm_test.py::TestFramePasswordChangeConfirmation::test_str
FAILED test/frame_password_enter_cfm_test.py::TestFramePasswordEnterConfirmation::test_str
FAILED test/frame_set_node_name_cfm_test.py::TestFrameSetNodeNameConfirmation::test_str
FAILED test/frame_status_request_test.py::TestFrameStatusRequestRequest::test_str
FAILED test/frame_status_request_test.py::TestFrameStatusRequestConfirmation::test_str
FAILED test/frame_status_request_test.py::TestFrameStatusRequestNotification::test_str
================= 21 failed, 293 passed, 57 warnings in 0.54s ==================


https://docs.python.org/3.11/whatsnew/3.11.html

For the build logs, see:
https://copr-be.cloud.fedoraproject.org/results/@python/python3.11/fedora-rawhide-x86_64/03272220-python-pyvlx/

For all our attempts to build python-pyvlx with Python 3.11, see:
https://copr.fedorainfracloud.org/coprs/g/python/python3.11/package/python-pyvlx/

Testing and mass rebuild of packages is happening in copr. You can follow these instructions to test locally in mock if your package builds with Python 3.11:
https://copr.fedorainfracloud.org/coprs/g/python/python3.11/

Let us know here if you have any questions.

Python 3.11 is planned to be included in Fedora 37. To make that update smoother, we're building Fedora packages with all pre-releases of Python 3.11.
A build failure prevents us from testing all dependent packages (transitive [Build]Requires), so if this package is required a lot, it's important for us to get it fixed soon.
We'd appreciate help from the people who know this package best, but if you don't want to work on this now, let us know so we can try to work around it on our side.