async def _feed_protocol_handlers(self, protocol: ProtocolAPI) -> None:
# do not start consuming from the protocol stream until
# `start_protocol_streams` has been called and the multiplexer is
# active.
try:
await asyncio.wait_for(asyncio.gather(self._handlers_ready.wait()),
timeout=10)
except asyncio.TimeoutError as err:
self.logger.info('Timedout waiting for handler ready signal')
raise asyncio.TimeoutError(
"The handlers ready event was never set. Ensure that "
"`Connection.start_protocol_streams()` is being called"
) from err
# we don't need to use wait_iter here because the multiplexer does it
# for us.
async for cmd in self._multiplexer.stream_protocol_messages(protocol):
self.logger.debug2('Handling command: %s', type(cmd))
# local copy to prevent multation while iterating
protocol_handlers = set(self._protocol_handlers[type(protocol)])
for proto_handler_fn in protocol_handlers:
self.logger.debug2(
'Running protocol handler %s for protocol=%s command=%s',
proto_handler_fn,
protocol,
type(cmd),
)
self.run_task(proto_handler_fn(self, cmd))
command_handlers = set(self._command_handlers[type(cmd)])
for cmd_handler_fn in command_handlers:
self.logger.debug2(
'Running command handler %s for protocol=%s command=%s',
cmd_handler_fn,
protocol,
type(cmd),
)
self.run_task(cmd_handler_fn(self, cmd))
def create(cls, serial_id):
""" Create a new asynchronous Linkbot object.
:param serial_id: The robot to connect to
:type serial_id: str
:returns: AsyncLinkbot() object.
"""
try:
self = cls()
self._proxy = yield from asyncio.wait_for(
_AsyncLinkbot.create(serial_id), util.DEFAULT_TIMEOUT)
self.rb_add_broadcast_handler = self._proxy.rb_add_broadcast_handler
self.close = self._proxy.close
self.enableButtonEvent = self._proxy.enableButtonEvent
self._accelerometer = yield from peripherals.Accelerometer.create(
self)
self._battery = yield from peripherals.Battery.create(self)
self._button = yield from peripherals.Button.create(self)
self._buzzer = yield from peripherals.Buzzer.create(self)
self._eeprom_obj = yield from peripherals.Eeprom.create(self)
self._led = yield from peripherals.Led.create(self)
self._motors = yield from peripherals.Motors.create(self)
self._twi = yield from peripherals.Twi.create(self)
self._serial_id = serial_id
# Enable joint events
yield from self._proxy.enableJointEvent(enable=True)
self._proxy.rb_add_broadcast_handler('jointEvent',
self.__joint_event)
self._proxy.rb_add_broadcast_handler('debugMessageEvent',
self.__debug_message_event)
return self
except asyncio.TimeoutError:
raise asyncio.TimeoutError(
'Timed out trying to connect to remote robot. Please ensure '
'that the remote robot is on and not currently connected to '
'another computer.')
async def on_response_message(self, message: IncomingMessage):
""" Process a response.
This method is used to process standard responses as well as requests
that expired and were sent to the dead letter exchange to which the
response queue is also linked to.
"""
await message.ack()
if message.correlation_id is None:
logger.warning(f"Message had no correlation_id: {message}")
return
f = self.futures.pop(
message.correlation_id, None
) # type: Optional[asyncio.Future]
if f is None:
logger.warning(
f"Unrecognized correlation_id: {message.correlation_id}: {message}"
)
return
if "x-death" in message.headers:
# The presence of the 'x-death' header indicates the return of an
# unprocessed request.
f.set_exception(asyncio.TimeoutError("Message timed-out"))
return
try:
payload = utils.decode_message(message)
except Exception as e:
logger.error(f"Failed to deserialize response on message: {message}")
f.set_exception(e)
return
f.set_result(payload)
def send_packet_and_watch(self, request_packet, retries=0, timeout=DEFAULT_RESPONSE_TIMEOUT):
"""
Send request packet to the server with timeout and trying to resend it some times
Params:
request_packet(aioradius.protocol.Packet) - packet for sending
retries(int) - number of resend attempts
timeout(int) - delay between resend attempts
Return:
response from server
"""
trying_idx = 0
response = None
if retries > 0:
retries -= 1
while trying_idx <= retries:
try:
response = yield from asyncio.wait_for(self.send_packet_once(request_packet), timeout)
except asyncio.TimeoutError:
trying_idx += 1
logger.warning("Timeout for {} ({} sec)".format(request_packet, timeout))
continue
except packet.PacketError:
trying_idx += 1
logger.warning("Validation error for {}".format(request_packet))
continue
else:
break
if response is not None:
return response
else:
raise asyncio.TimeoutError("All {} retries to sent {} are timed out".format(
retries + 1,
request_packet
))
async def _request(self,
unit: int,
function_code: int,
address: int,
*values: int,
decode_packing: str,
packet_length: int,
timeout: float = 0.1):
if unit is None:
unit = self.default_unit_id
async with self.transaction:
try:
await asyncio.wait_for(self.connected.wait(), 2)
except asyncio.TimeoutError as e:
raise asyncio.TimeoutError(
"Failed modbus request as client is not connected") from e
packet = self._encode_packet(unit, function_code, address, *values)
self.protocol.buffer.clear()
self.transport.write(packet)
unit_id, func_code, *values, crc = await self.protocol.decode(
packet_length, decode_packing, timeout=timeout)
assert unit_id == unit
assert function_code == func_code
return values
async def test_exception_handling():
"""Test handling of exceptions."""
send_messages = []
user = MockUser()
refresh_token = Mock()
conn = websocket_api.ActiveConnection(logging.getLogger(__name__), None,
send_messages.append, user,
refresh_token)
for (exc, code, err) in (
(exceptions.Unauthorized(), websocket_api.ERR_UNAUTHORIZED,
"Unauthorized"),
(
vol.Invalid("Invalid something"),
websocket_api.ERR_INVALID_FORMAT,
"Invalid something. Got {'id': 5}",
),
(asyncio.TimeoutError(), websocket_api.ERR_TIMEOUT, "Timeout"),
(
exceptions.HomeAssistantError("Failed to do X"),
websocket_api.ERR_UNKNOWN_ERROR,
"Failed to do X",
),
(ValueError("Really bad"), websocket_api.ERR_UNKNOWN_ERROR,
"Unknown error"),
(
exceptions.HomeAssistantError(),
websocket_api.ERR_UNKNOWN_ERROR,
"Unknown error",
),
):
send_messages.clear()
conn.async_handle_exception({"id": 5}, exc)
assert len(send_messages) == 1
assert send_messages[0]["error"]["code"] == code
assert send_messages[0]["error"]["message"] == err
async def simulate_and_collect_stats(self, testname, spec):
pools = [connpool.Pool, connpool._NaivePool]
js_data = []
for pool_cls in pools:
try:
data = await asyncio.wait_for(
self.simulate_once(
spec, pool_cls, collect_stats=True),
spec.timeout
)
except asyncio.TimeoutError:
raise asyncio.TimeoutError(f'timeout with {pool_cls!r}')
js_data.append(data)
js_data = {
'desc': textwrap.dedent(spec.desc) if spec.desc else None,
'test_name': testname,
'now': str(datetime.datetime.now()),
'spec': dataclasses.asdict(spec),
'runs': js_data
}
return js_data
async def result(
self, timeout: Optional[float] = None,
*, pole_delay: float = 0.5,
) -> Any:
"""
Get the result of the job, including waiting if it's not yet available.
If the job raised an exception, it will be raised here.
:param timeout: maximum time to wait for the job result before raising
``TimeoutError``, will wait forever
:param pole_delay: how often to poll redis for the job result
"""
async for delay in poll(pole_delay):
info = await self.result_info()
if info:
result = info.result
if info.success:
return result
elif isinstance(result, Exception):
raise result
else:
raise SerializationError(result)
if timeout is not None and delay > timeout:
raise asyncio.TimeoutError()
def test_setup_platform_timeout_loginpage(self, mock_error,
aioclient_mock):
"""Setup a platform with timeout on loginpage."""
aioclient_mock.get(
"http://{}/common_page/login.html".format(self.host),
exc=asyncio.TimeoutError()
)
aioclient_mock.post(
"http://{}/xml/getter.xml".format(self.host),
content=b'successful',
)
with assert_setup_component(1):
assert setup_component(
self.hass, DOMAIN, {DOMAIN: {
CONF_PLATFORM: 'upc_connect',
CONF_HOST: self.host,
CONF_PASSWORD: '******'
}})
assert len(aioclient_mock.mock_calls) == 1
assert 'Error setting up platform' in \
str(mock_error.call_args_list[-1])
async def start(self, **kwargs):
await super().start(**kwargs)
while (await self.describe_pod()).status.phase == "Pending":
await asyncio.sleep(0.1)
while self.address is None:
logs = await self.logs()
for line in logs.splitlines():
if "Scheduler at:" in line:
self.address = line.split("Scheduler at:")[1].strip()
await asyncio.sleep(0.1)
self.service = await self._create_service()
self.address = "tcp://{name}.{namespace}:{port}".format(
name=self.service.metadata.name,
namespace=self.namespace,
port=SCHEDULER_PORT,
)
if self.service.spec.type == "LoadBalancer":
# Wait for load balancer to be assigned
start = time.time()
while self.service.status.load_balancer.ingress is None:
if (self._service_wait_timeout_s > 0 and
time.time() > start + self._service_wait_timeout_s):
raise asyncio.TimeoutError(
"Timed out waiting for Load Balancer to be provisioned."
)
self.service = await self.core_api.read_namespaced_service(
self.cluster_name, self.namespace)
await asyncio.sleep(0.2)
[loadbalancer_ingress] = self.service.status.load_balancer.ingress
loadbalancer_host = loadbalancer_ingress.hostname or loadbalancer_ingress.ip
self.external_address = "tcp://{host}:{port}".format(
host=loadbalancer_host, port=SCHEDULER_PORT)
async def _fetch(self, url):
try:
# Set a timeout of 30 seconds
async with timeout(30.0):
headers = await self.get_headers()
# Fetch the url
async with self.session.get(url, headers=headers) as resp:
# If the get request failed in some way, return None
if resp.status != 200:
return None
# Convert the data to json format
data = await resp.json()
# If the request times out, raise a better error
except asyncio.TimeoutError:
raise asyncio.TimeoutError(f"Timed out while fetching '{url}'")
# This is probably useless, but just in case
if self.error_detector(data):
return None
return data
async def wait_till_subscriptions_active(self, subscriptions):
""":param subcriptions: [subscription, ...] or {subcription: timeout, ...}"""
timeouts_by_sub = subscriptions
if not isinstance(subscriptions, dict):
timeouts_by_sub = dict.fromkeys(subscriptions, None)
timeouts_by_sub = {
self.get_subscription(x): timeout
for x, timeout in timeouts_by_sub.items()
}
started = time.time()
while True:
not_active = [s for s in timeouts_by_sub if not s.state]
if not not_active:
break
elapsed = time.time() - started
exceeded = [
s for s in not_active if timeouts_by_sub[s] is not None
and elapsed > timeouts_by_sub[s]
]
if exceeded:
raise asyncio.TimeoutError(
'Subcription(s) {} have exceeded their timeout'.format(
exceeded))
await asyncio.sleep(0.05)
async def wait_for_serial(self, serial, timeout=DEFAULT_MAX_WAIT):
'''Wait for a device with the specified serial number to attach.
Args:
serial (string): Serial number of the device to wait for.
timeout (float): The maximum amount of time in seconds to wait for a
matching device to be connected.
Set to None to wait indefinitely, or -1 to only check currently
connected devices.
Returns:
int: The device id of the connected device
Raises:
asyncio.TimeoutError if the device with the specified serial number doesn't appear.
'''
timeout = Timeout(timeout)
with self.attach_watcher(include_existing=True) as watcher:
while not timeout.expired:
action, device_id, info = await watcher.wait_for_next(timeout.remaining)
if action != ACTION_ATTACHED:
continue
if info['SerialNumber'].lower() == serial.lower():
return device_id
raise asyncio.TimeoutError("No devices matching serial number found")
async def test_execute__with_attempt_timeout__idempotent(mocker):
cl = Cluster(["addr1"], max_attempts=3)
mocked_pooler = mocker.patch.object(cl, "_pooler", new=get_pooler_mock())
pool = mocked_pooler._pool
pool.execute.side_effect = asyncio.TimeoutError()
mocked_manager = mocker.patch.object(cl,
"_manager",
new=get_manager_mock())
state = mocked_manager.get_state.return_value
state.slot_master.return_value.addr = Address("1.2.3.4", 9999)
state.random_node.return_value.addr = Address("6.6.6.6", 9999)
mocked_execute_retry_slowdown = mocker.patch.object(
cl, "_execute_retry_slowdown", new=create_async_mock())
with pytest.raises(asyncio.TimeoutError):
await cl.execute("get", "key")
assert mocked_manager.get_state.call_count == 3
assert mocked_pooler.ensure_pool.call_count == 3
assert mocked_manager.require_reload_state.call_count == 3
assert mocked_execute_retry_slowdown.call_count == 2
async def test_async_step_bluetooth_valid_device_but_missing_payload(hass):
"""Test discovery via bluetooth with a valid device but missing payload."""
with patch(
"homeassistant.components.xiaomi_ble.config_flow.async_process_advertisements",
side_effect=asyncio.TimeoutError(),
):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_BLUETOOTH},
data=MISSING_PAYLOAD_ENCRYPTED,
)
assert result["type"] == FlowResultType.FORM
assert result["step_id"] == "confirm_slow"
with patch(
"homeassistant.components.xiaomi_ble.async_setup_entry", return_value=True
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"], user_input={}
)
assert result2["type"] == FlowResultType.CREATE_ENTRY
assert result2["title"] == "Temperature/Humidity Sensor 565384 (LYWSD03MMC)"
assert result2["data"] == {}
assert result2["result"].unique_id == "A4:C1:38:56:53:84"
async def test_simple_inspector_exception(aioresponses):
aioresponses.get(
"http://getstatuscode.com/timeout",
exception=asyncio.TimeoutError("test error"),
)
aioresponses.get(
"http://getstatuscode.com/error",
exception=aiohttp.ClientError("test error"),
)
client = HttpMonitor()
async with aiohttp.ClientSession() as session:
resp = await client.check(session,
url="http://getstatuscode.com/error")
assert resp.url == "http://getstatuscode.com/error"
assert resp.status_code == -1
assert resp.error == "test error"
assert not resp.ok
resp = await client.check(session,
url="http://getstatuscode.com/timeout")
assert resp.url == "http://getstatuscode.com/timeout"
assert resp.status_code == -1
assert resp.error == "host does not respond (timeout)"
assert not resp.ok
def _execute(self, method, path, params=None, timeout=None, loop=None):
if loop is None:
loop = self.loop
if timeout is None:
timeout = self.read_timeout
failed = False
# TODO: whatif self._machines_cache is empty ?
for idx, uri in enumerate(self._machines_cache):
try:
resp = yield from asyncio.wait_for(
aiohttp.request(
method, uri + path, params=params, loop=loop
),
timeout, loop=loop
)
if failed:
self._machine_cache = self._machine_cache[idx:]
if not self._cache_update_scheduled:
self._cache_update_scheduled = True
self.loop.create_task(self._update_machine_cache())
return resp
except asyncio.TimeoutError:
failed = True
raise asyncio.TimeoutError()
def first(futures: [asyncio.Future],
loop,
timeout=None,
cancel_others=True):
"""Return first future and cancel others."""
# wait for first
try:
done, pending = yield from asyncio.wait(
iter(futures),
loop=loop,
timeout=timeout,
return_when=asyncio.FIRST_COMPLETED)
except asyncio.CancelledError:
Util.cancel_futures(futures)
raise
if cancel_others:
# cancel all other futures
for future in pending:
future.cancel()
if not done:
raise asyncio.TimeoutError()
return next(iter(done))
async def wait(self,
tx: basetransaction.BaseTransaction,
height=-1,
timeout=None):
addresses = set()
for txi in tx.inputs:
if txi.txo_ref.txo is not None:
addresses.add(
self.hash160_to_address(
txi.txo_ref.txo.script.values['pubkey_hash']))
for txo in tx.outputs:
addresses.add(
self.hash160_to_address(txo.script.values['pubkey_hash']))
records = await self.db.get_addresses(address__in=addresses)
_, pending = await asyncio.wait([
self.on_transaction.where(
partial(
lambda a, e: a == e.address and e.tx.height >= height and e
.tx.id == tx.id, address_record['address']))
for address_record in records
],
timeout=timeout)
if pending:
raise asyncio.TimeoutError('Timed out waiting for transaction.')
def test_service_say_timeout(self, aioclient_mock):
"""Test service call say."""
calls = mock_service(self.hass, DOMAIN_MP, SERVICE_PLAY_MEDIA)
aioclient_mock.get(
self.url, params=self.url_param, status=200,
exc=asyncio.TimeoutError())
config = {
tts.DOMAIN: {
'platform': 'marytts',
}
}
with assert_setup_component(1, tts.DOMAIN):
setup_component(self.hass, tts.DOMAIN, config)
self.hass.services.call(tts.DOMAIN, 'marytts_say', {
tts.ATTR_MESSAGE: "HomeAssistant",
})
self.hass.block_till_done()
assert len(calls) == 0
assert len(aioclient_mock.mock_calls) == 1
def test_value_reader_read_timeout(self, logger_warning_mock):
"""Test value reader: read timeout."""
xknx = XKNX()
value_reader = ValueReader(xknx, GroupAddress("0/0/0"))
value_reader.response_received_or_timeout.wait = MagicMock(
side_effect=asyncio.TimeoutError()
)
timed_out_read = self.loop.run_until_complete(value_reader.read())
# GroupValueRead telegram is still in the queue because we are not actually processing it
self.assertEqual(xknx.telegrams.qsize(), 1)
# Warning was logged
logger_warning_mock.assert_called_once_with(
"Error: KNX bus did not respond in time (%s secs) to GroupValueRead request for: %s",
2.0,
GroupAddress("0/0/0"),
)
# Callback was removed again
self.assertEqual(xknx.telegram_queue.telegram_received_cbs, [])
# No telegram was received
self.assertIsNone(value_reader.received_telegram)
# Unsuccessfull read() returns None
self.assertIsNone(timed_out_read)
async def test_watch_timeout(self):
fake_resp = CoroutineMock()
fake_resp.content.readline = CoroutineMock()
fake_resp.release = Mock()
mock_event = {
"type": "ADDED",
"object": {
"metadata": {
"name": "test1555",
"resourceVersion": "1555"
},
"spec": {},
"status": {}
}
}
fake_resp.content.readline.side_effect = [
json.dumps(mock_event).encode('utf8'),
asyncio.TimeoutError(), b""
]
fake_api = Mock()
fake_api.get_namespaces = CoroutineMock(return_value=fake_resp)
fake_api.get_namespaces.__doc__ = ':return: V1NamespaceList'
watch = kubernetes_asyncio.watch.Watch()
async with watch.stream(fake_api.get_namespaces) as stream:
async for e in stream: # noqa
pass
fake_api.get_namespaces.assert_has_calls([
call(_preload_content=False, watch=True),
call(_preload_content=False, watch=True, resource_version='1555')
])
fake_resp.release.assert_called_once_with()
async def _wait_for_message_by_key(
self, key: Any, *, timeout: float = None, max_interval: float = 2.0
) -> SignalEvent:
app = self.case.app
time_start = monotonic()
remaining = timeout
# See if the key is already there.
try:
return self._get_current_value(key)
except KeyError:
pass
# If not, wait for it to arrive.
while not app.should_stop:
if remaining is not None:
remaining = remaining - (monotonic() - time_start)
try:
if remaining is not None and remaining <= 0.0:
try:
return self._get_current_value(key)
except KeyError:
raise asyncio.TimeoutError() from None
max_wait = None
if remaining is not None:
max_wait = min(remaining, max_interval)
await self._wait_for_resolved(timeout=max_wait)
except asyncio.TimeoutError:
msg = f"Timed out waiting for signal {self.name} ({timeout})"
raise LiveCheckTestTimeout(msg) from None
if app.should_stop:
break
try:
val = self._get_current_value(key)
return val
except KeyError:
pass
raise asyncio.CancelledError()
async def receive_vrfyres(self, timeout: float) -> Optional[Segment]:
"""Variant of BaseTest.receive that allows checksum errors."""
while timeout > 0:
start = time.monotonic()
data = await asyncio.wait_for(self.recv_queue.get(),
timeout,
loop=self._loop)
timeout -= (time.monotonic() - start)
try:
seg = Segment.from_bytes(self.dst.ip.packed,
self.src.ip.packed, data)
except ChecksumError:
return None
except ValueError:
# Discard invalid segments silently and retry
pass
else:
if seg.flags & 0x02:
# Collect ISNs for ISN predictability meta-test
self._isns.append((time.monotonic(), seg.seq))
return seg
raise asyncio.TimeoutError()
assert result["data"] == {
"url": "ws://host1:3001",
"usb_path": "/test",
"network_key": "abc123",
"use_addon": True,
"integration_created_addon": False,
}
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1
@pytest.mark.parametrize(
"discovery_info, server_version_side_effect",
[({
"config": ADDON_DISCOVERY_INFO
}, asyncio.TimeoutError())],
)
async def test_supervisor_discovery_cannot_connect(opp, supervisor,
get_addon_discovery_info):
"""Test Supervisor discovery and cannot connect."""
await setup.async_setup_component(opp, "persistent_notification", {})
result = await opp.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_OPPIO},
data=ADDON_DISCOVERY_INFO,
)
assert result["type"] == "abort"
assert result["reason"] == "cannot_connect"
def watchdog_cb(fut: Awaitable) -> None:
self._raise_error(asyncio.TimeoutError(
'Navigation Timeout Exceeded: {} ms exceeded'.format(
self._timeout)
))
def _pong_not_received(self) -> None:
if self._req is not None and self._req.transport is not None:
self._closed = True
self._close_code = WSCloseCode.ABNORMAL_CLOSURE
self._exception = asyncio.TimeoutError()
self._req.transport.close()
@pytest.mark.asyncio
async def test_servers_cache_failure(client, protocol_client, backend_client,
servers_cache):
servers_cache.get.return_value = async_raise(AccessDenied())
await client.run()
servers_cache.get.assert_called_once_with()
backend_client.get_authentication_data.assert_not_called()
protocol_client.authenticate.assert_not_called()
protocol_client.run.assert_not_called()
@pytest.mark.asyncio
@pytest.mark.parametrize("exception", [
asyncio.TimeoutError(),
IOError(),
websockets.InvalidURI("wss://websocket_1"),
websockets.InvalidHandshake()
])
async def test_connect_error(client, backend_client, protocol_client,
servers_cache, mocker, exception):
servers_cache.get.side_effect = [
async_return_value(["wss://websocket_1", "wss://websocket_2"]),
]
connect = mocker.patch(
"protocol.websocket_client.websockets.connect",
side_effect=[async_raise(exception),
async_return_value(MagicMock())])
backend_client.get_authentication_data.return_value = STEAM_ID, ACCOUNT_NAME, TOKEN
protocol_client.authenticate.return_value = async_return_value(None)
async def call(self, payload, suppress=True):
"""
Send Call message to client and return payload of response.
The given payload is transformed into a Call object by looking at the
type of the payload. A payload of type BootNotificationPayload will
turn in a Call with Action BootNotification, a HeartbeatPayload will
result in a Call with Action Heartbeat etc.
A timeout is raised when no response has arrived before expiring of
the configured timeout.
When waiting for a response no other Call message can be send. So this
function will wait before response arrives or response timeout has
expired. This is in line the OCPP specification
Suppress is used to maintain backwards compatibility. When set to True,
if response is a CallError, then this call will be suppressed. When
set to False, an exception will be raised for users to handle this
CallError.
"""
camel_case_payload = snake_to_camel_case(asdict(payload))
call = Call(
unique_id=str(self._unique_id_generator()),
action=payload.__class__.__name__[:-7],
payload=remove_nones(camel_case_payload)
)
validate_payload(call, self._ocpp_version)
# Use a lock to prevent make sure that only 1 message can be send at a
# a time.
async with self._call_lock:
await self._send(call.to_json())
try:
response = \
await self._get_specific_response(call.unique_id,
self._response_timeout)
except asyncio.TimeoutError:
raise asyncio.TimeoutError(
f"Waited {self._response_timeout}s for response on "
f"{call.to_json()}."
)
if response.message_type_id == MessageType.CallError:
LOGGER.warning("Received a CALLError: %s'", response)
if suppress:
return
raise response.to_exception()
else:
response.action = call.action
validate_payload(response, self._ocpp_version)
snake_case_payload = camel_to_snake_case(response.payload)
# Create the correct Payload instance based on the received payload. If
# this method is called with a call.BootNotificationPayload, then it
# will create a call_result.BootNotificationPayload. If this method is
# called with a call.HeartbeatPayload, then it will create a
# call_result.HeartbeatPayload etc.
cls = getattr(self._call_result, payload.__class__.__name__) # noqa
return cls(**snake_case_payload)
async def on_wait_for(*args, **kwargs):
if wait_for.call_count >= 2:
sup._stopped.set()
raise asyncio.TimeoutError()
