Repository: XKNX/xknx
Pull request #1491 (2024-06-17 19:33:45)

Non-awaitable Device telegram process
<!--
  You are awesome! Thanks for contributing to our project!
  Please, DO NOT DELETE ANY TEXT from this template!.
-->
## Description
<!--
Please include a summary of the change and which issue is fixed.
Please also include relevant motivation and context.
List any dependencies that are required for this change.
-->


Fixes # (issue)

## Type of change
<!--
Please tick the applicable options.
NOTE: Ticking multiple options most likely indicates
that your change is to big and it is suggested to split it into several smaller PRs.
-->

- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [x] Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] Code quality improvements to existing code or addition of tests

## Checklist

- [ ] The documentation has been adjusted accordingly
- [x] Tests have been added that prove the fix is effective or that the feature works
- [x] The changes are documented in the changelog (docs/changelog.md)

codecov[bot]: ## [Codecov](https://app.codecov.io/gh/XKNX/xknx/pull/1491?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX) Report
All modified and coverable lines are covered by tests :white_check_mark:
> Project coverage is 96.63%. Comparing base [(`8270396`)](https://app.codecov.io/gh/XKNX/xknx/commit/8270396eb7430de64eab0fab01619d37e8302f0d?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX) to head [(`c8ab228`)](https://app.codecov.io/gh/XKNX/xknx/commit/c8ab228ecb3eccd84dea10ad5ae07997a2b0706f?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX).

<details><summary>Additional details and impacted files</summary>


[![Impacted file tree graph](https://app.codecov.io/gh/XKNX/xknx/pull/1491/graphs/tree.svg?width=650&height=150&src=pr&token=irWbIygS84&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX)](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX)

```diff
@@           Coverage Diff           @@
##             main    #1491   +/-   ##
=======================================
  Coverage   96.63%   96.63%           
=======================================
  Files         154      154           
  Lines       10025    10026    +1     
=======================================
+ Hits         9688     9689    +1     
  Misses        337      337           
```


| [Files](https://app.codecov.io/gh/XKNX/xknx/pull/1491?dropdown=coverage&src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX) | Coverage Δ | |
|---|---|---|
| [xknx/core/telegram\_queue.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fcore%2Ftelegram_queue.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9jb3JlL3RlbGVncmFtX3F1ZXVlLnB5) | `98.30% <100.00%> (ø)` | |
| [xknx/devices/binary\_sensor.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Fbinary_sensor.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2JpbmFyeV9zZW5zb3IucHk=) | `98.93% <100.00%> (ø)` | |
| [xknx/devices/climate.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Fclimate.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2NsaW1hdGUucHk=) | `100.00% <100.00%> (ø)` | |
| [xknx/devices/climate\_mode.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Fclimate_mode.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2NsaW1hdGVfbW9kZS5weQ==) | `100.00% <100.00%> (ø)` | |
| [xknx/devices/cover.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Fcover.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2NvdmVyLnB5) | `99.47% <100.00%> (ø)` | |
| [xknx/devices/datetime.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Fdatetime.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2RhdGV0aW1lLnB5) | `100.00% <100.00%> (ø)` | |
| [xknx/devices/device.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Fdevice.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2RldmljZS5weQ==) | `100.00% <100.00%> (ø)` | |
| [xknx/devices/devices.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Fdevices.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2RldmljZXMucHk=) | `100.00% <100.00%> (ø)` | |
| [xknx/devices/expose\_sensor.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Fexpose_sensor.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2V4cG9zZV9zZW5zb3IucHk=) | `100.00% <100.00%> (ø)` | |
| [xknx/devices/fan.py](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree&filepath=xknx%2Fdevices%2Ffan.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX#diff-eGtueC9kZXZpY2VzL2Zhbi5weQ==) | `100.00% <100.00%> (ø)` | |
| ... and [7 more](https://app.codecov.io/gh/XKNX/xknx/pull/1491?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=XKNX) | |

</details>

Patch:
diff --git a/docs/changelog.md b/docs/changelog.md
index 8231611a..423d4a5f 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -15,6 +15,8 @@ nav_order: 2
 - Remove `async` from functions / methods (nothing has to be awaited there)
   - Tools:  `group_value_write`, `group_value_response` and `group_value_read`
   - ConnectionManager: `.connection_state_changed`
+  - Device: `.process`, `.process_group_write`, `.process_group_read`, `.process_group_response`
+  - Devices: `.process`
   - RemoteValue: `.set`, `.respond`, `.process` and `.update_value`
   - ValueReader: `.send_group_read`
 
diff --git a/xknx/core/telegram_queue.py b/xknx/core/telegram_queue.py
index e749192b..82a1459a 100644
--- a/xknx/core/telegram_queue.py
+++ b/xknx/core/telegram_queue.py
@@ -206,16 +206,16 @@ class TelegramQueue:
             # raises CommunicationError when interface is not connected
             await self.xknx.cemi_handler.send_telegram(telegram)
 
-        await self.xknx.devices.process(telegram)
-        await self._run_telegram_received_cbs(telegram)
+        self.xknx.devices.process(telegram)
+        self._run_telegram_received_cbs(telegram)
 
     async def process_telegram_incoming(self, telegram: Telegram) -> None:
         """Process incoming telegram."""
         telegram_logger.debug(telegram)
-        await self._run_telegram_received_cbs(telegram)
-        await self.xknx.devices.process(telegram)
+        self._run_telegram_received_cbs(telegram)
+        self.xknx.devices.process(telegram)
 
-    async def _run_telegram_received_cbs(self, telegram: Telegram) -> None:
+    def _run_telegram_received_cbs(self, telegram: Telegram) -> None:
         """Run registered callbacks. Don't propagate exceptions."""
         for callback in self.telegram_received_cbs:
             if not callback.is_within_filter(telegram):
diff --git a/xknx/devices/binary_sensor.py b/xknx/devices/binary_sensor.py
index 446ea707..62861c13 100644
--- a/xknx/devices/binary_sensor.py
+++ b/xknx/devices/binary_sensor.py
@@ -145,12 +145,12 @@ class BinarySensor(Device):
             self._count_set_off = 1
         return 1
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         if self.remote_value.process(telegram, always_callback=True):
             self._process_reset_after()
 
-    async def process_group_response(self, telegram: Telegram) -> None:
+    def process_group_response(self, telegram: Telegram) -> None:
         """Process incoming GroupValueResponse telegrams."""
         if self.remote_value.process(telegram, always_callback=False):
             self._process_reset_after()
diff --git a/xknx/devices/climate.py b/xknx/devices/climate.py
index d0defb4f..09e93ef9 100644
--- a/xknx/devices/climate.py
+++ b/xknx/devices/climate.py
@@ -264,13 +264,13 @@ class Climate(Device):
             return self.base_temperature + self.setpoint_shift_min
         return None
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         for remote_value in self._iter_remote_values():
             remote_value.process(telegram)
 
         if self.mode is not None:
-            await self.mode.process_group_write(telegram)
+            self.mode.process_group_write(telegram)
 
     async def sync(self, wait_for_result: bool = False) -> None:
         """Read states of device from KNX bus."""
diff --git a/xknx/devices/climate_mode.py b/xknx/devices/climate_mode.py
index b903ac6b..58672c3d 100644
--- a/xknx/devices/climate_mode.py
+++ b/xknx/devices/climate_mode.py
@@ -303,7 +303,7 @@ class ClimateMode(Device):
         # remove duplicates
         return list(set(controller_modes))
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         if self.supports_operation_mode:
             for rv_mode in self._iter_operation_remote_values():
diff --git a/xknx/devices/cover.py b/xknx/devices/cover.py
index 16877ea8..665a81d2 100644
--- a/xknx/devices/cover.py
+++ b/xknx/devices/cover.py
@@ -340,7 +340,7 @@ class Cover(Device):
         await self.position_current.read_state(wait_for_result=wait_for_result)
         await self.angle.read_state(wait_for_result=wait_for_result)
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         # call after_update to account for travelcalculator changes
         if self.updown.process(telegram):
diff --git a/xknx/devices/datetime.py b/xknx/devices/datetime.py
index be7bb76a..1bc14170 100644
--- a/xknx/devices/datetime.py
+++ b/xknx/devices/datetime.py
@@ -79,7 +79,7 @@ class DateTime(Device):
         async def broadcast_loop(self: DateTime, minutes: int) -> None:
             """Endless loop for broadcasting local time."""
             while True:
-                await self.broadcast_localtime()
+                self.broadcast_localtime()
                 await asyncio.sleep(minutes * 60)
 
         self._broadcast_task = self.xknx.task_registry.register(
@@ -94,7 +94,7 @@ class DateTime(Device):
             self.xknx.task_registry.unregister(self._broadcast_task.name)
             self._broadcast_task = None
 
-    async def broadcast_localtime(self, response: bool = False) -> None:
+    def broadcast_localtime(self, response: bool = False) -> None:
         """Broadcast the local time to KNX bus."""
         self.remote_value.set(time.localtime(), response=response)
 
@@ -102,14 +102,14 @@ class DateTime(Device):
         """Set time and send to KNX bus."""
         self.remote_value.set(struct_time)
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         self.remote_value.process(telegram)
 
-    async def process_group_read(self, telegram: Telegram) -> None:
+    def process_group_read(self, telegram: Telegram) -> None:
         """Process incoming GROUP READ telegram."""
         if self.localtime:
-            await self.broadcast_localtime(True)
+            self.broadcast_localtime(True)
         elif (
             self.respond_to_read
             and telegram.destination_address == self.remote_value.group_address
@@ -119,7 +119,7 @@ class DateTime(Device):
     async def sync(self, wait_for_result: bool = False) -> None:
         """Read state of device from KNX bus. Used here to broadcast time to KNX bus."""
         if self.localtime:
-            await self.broadcast_localtime(response=False)
+            self.broadcast_localtime(response=False)
         else:
             await super().sync(wait_for_result)
 
diff --git a/xknx/devices/device.py b/xknx/devices/device.py
index 8067efce..19cf32c9 100644
--- a/xknx/devices/device.py
+++ b/xknx/devices/device.py
@@ -93,26 +93,26 @@ class Device(ABC):
         for remote_value in self._iter_remote_values():
             await remote_value.read_state(wait_for_result=wait_for_result)
 
-    async def process(self, telegram: Telegram) -> None:
+    def process(self, telegram: Telegram) -> None:
         """Process incoming telegram."""
         if isinstance(telegram.payload, GroupValueWrite):
-            await self.process_group_write(telegram)
+            self.process_group_write(telegram)
         elif isinstance(telegram.payload, GroupValueResponse):
-            await self.process_group_response(telegram)
+            self.process_group_response(telegram)
         elif isinstance(telegram.payload, GroupValueRead):
-            await self.process_group_read(telegram)
+            self.process_group_read(telegram)
 
-    async def process_group_read(self, telegram: Telegram) -> None:
+    def process_group_read(self, telegram: Telegram) -> None:
         """Process incoming GroupValueRead telegrams."""
         # The default is, that devices don't answer to group reads
         return
 
-    async def process_group_response(self, telegram: Telegram) -> None:
+    def process_group_response(self, telegram: Telegram) -> None:
         """Process incoming GroupValueResponse telegrams."""
         # Per default mapped to group write.
-        await self.process_group_write(telegram)
+        self.process_group_write(telegram)
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming GroupValueWrite telegrams."""
         # The default is, that devices don't process group writes
         return
diff --git a/xknx/devices/devices.py b/xknx/devices/devices.py
index 53cbf67a..583c9611 100644
--- a/xknx/devices/devices.py
+++ b/xknx/devices/devices.py
@@ -97,19 +97,13 @@ class Devices:
         for device_updated_cb in self.device_updated_cbs:
             device_updated_cb(device)
 
-    async def process(self, telegram: Telegram) -> None:
+    def process(self, telegram: Telegram) -> None:
         """Process telegram."""
         if isinstance(
             telegram.destination_address, GroupAddress | InternalGroupAddress
         ):
-            await asyncio.gather(
-                *[
-                    device.process(telegram)
-                    for device in self.devices_by_group_address(
-                        telegram.destination_address
-                    )
-                ]
-            )
+            for device in self.devices_by_group_address(telegram.destination_address):
+                device.process(telegram)
 
     async def sync(self) -> None:
         """Read state of devices from KNX bus."""
diff --git a/xknx/devices/expose_sensor.py b/xknx/devices/expose_sensor.py
index 5f2166cb..3e94b503 100644
--- a/xknx/devices/expose_sensor.py
+++ b/xknx/devices/expose_sensor.py
@@ -86,11 +86,11 @@ class ExposeSensor(Device):
             self.xknx.task_registry.unregister(self._cooldown_task.name)
             self._cooldown_task = None
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         self.sensor_value.process(telegram)
 
-    async def process_group_read(self, telegram: Telegram) -> None:
+    def process_group_read(self, telegram: Telegram) -> None:
         """Process incoming GROUP READ telegram."""
         if not self.respond_to_read:
             return
diff --git a/xknx/devices/fan.py b/xknx/devices/fan.py
index daef9fc2..effe7ff9 100644
--- a/xknx/devices/fan.py
+++ b/xknx/devices/fan.py
@@ -152,7 +152,7 @@ class Fan(Device):
         """Set the fan oscillation mode on or off."""
         self.oscillation.set(oscillation)
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         self.switch.process(telegram)
         self.speed.process(telegram)
diff --git a/xknx/devices/light.py b/xknx/devices/light.py
index dfc1d2f8..c540dbe1 100644
--- a/xknx/devices/light.py
+++ b/xknx/devices/light.py
@@ -611,7 +611,7 @@ class Light(Device):
             return
         self.color_temperature.set(color_temperature)
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         for remote_value in self._iter_instant_remote_values():
             remote_value.process(telegram)
diff --git a/xknx/devices/notification.py b/xknx/devices/notification.py
index fb156414..d89bcc52 100644
--- a/xknx/devices/notification.py
+++ b/xknx/devices/notification.py
@@ -57,11 +57,11 @@ class Notification(Device):
         cropped_message = message[:14]
         self.remote_value.set(cropped_message)
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         self.remote_value.process(telegram)
 
-    async def process_group_read(self, telegram: Telegram) -> None:
+    def process_group_read(self, telegram: Telegram) -> None:
         """Process incoming GroupValueResponse telegrams."""
         if (
             self.respond_to_read
diff --git a/xknx/devices/numeric_value.py b/xknx/devices/numeric_value.py
index f9f4cb0e..91e328a8 100644
--- a/xknx/devices/numeric_value.py
+++ b/xknx/devices/numeric_value.py
@@ -60,11 +60,11 @@ class NumericValue(Device):
         """Return the last telegram received from the RemoteValue."""
         return self.sensor_value.telegram
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         self.sensor_value.process(telegram, always_callback=self.always_callback)
 
-    async def process_group_read(self, telegram: Telegram) -> None:
+    def process_group_read(self, telegram: Telegram) -> None:
         """Process incoming GroupValueResponse telegrams."""
         if (
             self.respond_to_read
diff --git a/xknx/devices/raw_value.py b/xknx/devices/raw_value.py
index 554727f1..a8476617 100644
--- a/xknx/devices/raw_value.py
+++ b/xknx/devices/raw_value.py
@@ -60,11 +60,11 @@ class RawValue(Device):
         """Return the last telegram received from the RemoteValue."""
         return self.remote_value.telegram
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         self.remote_value.process(telegram, always_callback=self.always_callback)
 
-    async def process_group_read(self, telegram: Telegram) -> None:
+    def process_group_read(self, telegram: Telegram) -> None:
         """Process incoming GroupValueResponse telegrams."""
         if (
             self.respond_to_read
diff --git a/xknx/devices/sensor.py b/xknx/devices/sensor.py
index 65607630..7066d470 100644
--- a/xknx/devices/sensor.py
+++ b/xknx/devices/sensor.py
@@ -77,11 +77,11 @@ class Sensor(Device):
         """Return the last telegram received from the RemoteValue."""
         return self.sensor_value.telegram
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         self.sensor_value.process(telegram, always_callback=self.always_callback)
 
-    async def process_group_response(self, telegram: Telegram) -> None:
+    def process_group_response(self, telegram: Telegram) -> None:
         """Process incoming GroupValueResponse telegrams."""
         self.sensor_value.process(telegram)
 
diff --git a/xknx/devices/switch.py b/xknx/devices/switch.py
index b5dd3772..eaebd264 100644
--- a/xknx/devices/switch.py
+++ b/xknx/devices/switch.py
@@ -81,7 +81,7 @@ class Switch(Device):
         """Switch off switch."""
         self.switch.off()
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         if self.switch.process(telegram):
             if self.reset_after is not None and self.switch.value:
@@ -91,7 +91,7 @@ class Switch(Device):
                     track_task=True,
                 ).start()
 
-    async def process_group_read(self, telegram: Telegram) -> None:
+    def process_group_read(self, telegram: Telegram) -> None:
         """Process incoming GroupValueResponse telegrams."""
         if (
             self.respond_to_read
diff --git a/xknx/devices/weather.py b/xknx/devices/weather.py
index 19969135..b7e625f9 100644
--- a/xknx/devices/weather.py
+++ b/xknx/devices/weather.py
@@ -247,7 +247,7 @@ class Weather(Device):
         yield self._air_pressure
         yield self._humidity
 
-    async def process_group_write(self, telegram: Telegram) -> None:
+    def process_group_write(self, telegram: Telegram) -> None:
         """Process incoming and outgoing GROUP WRITE telegram."""
         for remote_value in self._iter_remote_values():
             remote_value.process(telegram)


Test patch:
diff --git a/test/core_tests/telegram_queue_test.py b/test/core_tests/telegram_queue_test.py
index f916023e..61d02024 100644
--- a/test/core_tests/telegram_queue_test.py
+++ b/test/core_tests/telegram_queue_test.py
@@ -179,7 +179,7 @@ class TestTelegramQueue:
         """Test process_telegram_incoming for forwarding telegram to a device."""
 
         xknx = XKNX()
-        test_device = AsyncMock()
+        test_device = Mock()
         devices_by_ga_mock.return_value = [test_device]
 
         telegram = Telegram(
@@ -191,7 +191,7 @@ class TestTelegramQueue:
         devices_by_ga_mock.assert_called_once_with(GroupAddress("1/2/3"))
         test_device.process.assert_called_once_with(telegram)
 
-    @patch("xknx.devices.Devices.process", new_callable=AsyncMock)
+    @patch("xknx.devices.Devices.process")
     async def test_process_to_callback(self, devices_process):
         """Test process_telegram_incoming with callback."""
 
diff --git a/test/devices_tests/binary_sensor_test.py b/test/devices_tests/binary_sensor_test.py
index 4152c783..be50bf9e 100644
--- a/test/devices_tests/binary_sensor_test.py
+++ b/test/devices_tests/binary_sensor_test.py
@@ -26,14 +26,14 @@ class TestBinarySensor:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await binaryinput.process(telegram_on)
+        binaryinput.process(telegram_on)
         assert binaryinput.state is True
 
         telegram_off = Telegram(
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(0)),
         )
-        await binaryinput.process(telegram_off)
+        binaryinput.process(telegram_off)
         assert binaryinput.state is False
 
         binaryinput2 = BinarySensor(xknx, "TestInput", "1/2/4")
@@ -43,7 +43,7 @@ class TestBinarySensor:
             destination_address=GroupAddress("1/2/4"),
             payload=GroupValueWrite(DPTBinary(0)),
         )
-        await binaryinput2.process(telegram_off2)
+        binaryinput2.process(telegram_off2)
         assert binaryinput2.last_telegram == telegram_off2
         assert binaryinput2.state is False
 
@@ -58,7 +58,7 @@ class TestBinarySensor:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(0)),
         )
-        await bs_invert.process(telegram_on)
+        bs_invert.process(telegram_on)
 
         assert bs_invert.state is True
 
@@ -66,7 +66,7 @@ class TestBinarySensor:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await bs_invert.process(telegram_off)
+        bs_invert.process(telegram_off)
         assert bs_invert.state is False
 
     async def test_process_reset_after(self, time_travel):
@@ -86,7 +86,7 @@ class TestBinarySensor:
             payload=GroupValueWrite(DPTBinary(1)),
         )
 
-        await binaryinput.process(telegram_on)
+        binaryinput.process(telegram_on)
         assert binaryinput.state
 
         await time_travel(reset_after_sec)
@@ -96,10 +96,10 @@ class TestBinarySensor:
 
         after_update_callback.reset_mock()
         # multiple telegrams during reset_after time period shall reset timer
-        await binaryinput.process(telegram_on)
+        binaryinput.process(telegram_on)
         after_update_callback.assert_called_once()
-        await binaryinput.process(telegram_on)
-        await binaryinput.process(telegram_on)
+        binaryinput.process(telegram_on)
+        binaryinput.process(telegram_on)
         # second and third telegram resets timer but doesn't run callback
         after_update_callback.assert_called_once()
         assert binaryinput.state
@@ -118,7 +118,7 @@ class TestBinarySensor:
             payload=GroupValueWrite(DPTArray((0x1, 0x2, 0x3))),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await binary_sensor.process(telegram)
+            binary_sensor.process(telegram)
             log_mock.assert_called_once()
             assert binary_sensor.state is None
 
@@ -165,14 +165,14 @@ class TestBinarySensor:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await switch.process(telegram)
+        switch.process(telegram)
         # no _context_task started because ignore_internal_state is False
         assert switch._context_task is None
         after_update_callback.assert_called_once_with(switch)
 
         after_update_callback.reset_mock()
         # send same telegram again
-        await switch.process(telegram)
+        switch.process(telegram)
         after_update_callback.assert_not_called()
 
     async def test_process_callback_ignore_internal_state(self):
@@ -195,7 +195,7 @@ class TestBinarySensor:
         )
         assert switch.counter == 0
 
-        await switch.process(telegram)
+        switch.process(telegram)
         after_update_callback.assert_not_called()
         assert switch.counter == 1
         await switch._context_task
@@ -205,9 +205,9 @@ class TestBinarySensor:
 
         after_update_callback.reset_mock()
         # send same telegram again
-        await switch.process(telegram)
+        switch.process(telegram)
         assert switch.counter == 1
-        await switch.process(telegram)
+        switch.process(telegram)
         assert switch.counter == 2
         after_update_callback.assert_not_called()
 
@@ -235,14 +235,14 @@ class TestBinarySensor:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await switch.process(telegram)
+        switch.process(telegram)
         # no _context_task started because context_timeout is False
         assert switch._context_task is None
         after_update_callback.assert_called_once_with(switch)
 
         after_update_callback.reset_mock()
         # send same telegram again
-        await switch.process(telegram)
+        switch.process(telegram)
         after_update_callback.assert_called_once_with(switch)
 
     async def test_process_group_value_response(self):
@@ -270,17 +270,17 @@ class TestBinarySensor:
         )
         assert switch.state is None
         # initial GroupValueResponse changes state and runs callback
-        await switch.process(response_telegram)
+        switch.process(response_telegram)
         assert switch.state
         after_update_callback.assert_called_once_with(switch)
         # GroupValueWrite with same payload runs callback because of `ignore_internal_state`
         after_update_callback.reset_mock()
-        await switch.process(write_telegram)
+        switch.process(write_telegram)
         assert switch.state
         after_update_callback.assert_called_once_with(switch)
         # GroupValueResponse should not run callback when state has not changed
         after_update_callback.reset_mock()
-        await switch.process(response_telegram)
+        switch.process(response_telegram)
         after_update_callback.assert_not_called()
 
     #
@@ -330,7 +330,7 @@ class TestBinarySensor:
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueWrite(DPTBinary(1)),
             )
-            await switch.process(write_telegram)
+            switch.process(write_telegram)
             assert switch._context_task
             assert switch._reset_task
             xknx.devices.async_remove(switch)
diff --git a/test/devices_tests/climate_test.py b/test/devices_tests/climate_test.py
index d6059369..5a498d91 100644
--- a/test/devices_tests/climate_test.py
+++ b/test/devices_tests/climate_test.py
@@ -152,12 +152,12 @@ class TestClimate:
         xknx.devices.async_add(climate)
 
         climate.target_temperature.set(23.00)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         after_update_callback.assert_called_with(climate)
         after_update_callback.reset_mock()
 
         await climate.set_setpoint_shift(-2)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         after_update_callback.assert_called_with(climate)
         after_update_callback.reset_mock()
 
@@ -203,7 +203,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/1"),
             payload=GroupValueWrite(DPTTemperature.to_knx(23)),
         )
-        await climate.process(telegram)
+        climate.process(telegram)
         after_update_callback.assert_called_with(climate)
         after_update_callback.reset_mock()
 
@@ -211,7 +211,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPTTemperature.to_knx(23)),
         )
-        await climate.process(telegram)
+        climate.process(telegram)
         after_update_callback.assert_called_with(climate)
         after_update_callback.reset_mock()
 
@@ -219,7 +219,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTValue1Count.to_knx(-4)),
         )
-        await climate.process(telegram)
+        climate.process(telegram)
         after_update_callback.assert_called_with(climate)
         after_update_callback.reset_mock()
 
@@ -241,7 +241,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/4"),
             payload=GroupValueWrite(DPTArray(1)),
         )
-        await climate.process(telegram)
+        climate.process(telegram)
         after_update_callback.assert_called_with(climate_mode)
         after_update_callback.reset_mock()
 
@@ -394,7 +394,7 @@ class TestClimate:
         xknx.devices.async_add(climate2)
         assert not climate2.initialized_for_setpoint_shift_calculations
         await climate2.set_setpoint_shift(4)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         assert not climate2.initialized_for_setpoint_shift_calculations
 
         climate3 = Climate(
@@ -406,11 +406,11 @@ class TestClimate:
         )
         xknx.devices.async_add(climate3)
         await climate3.set_setpoint_shift(4)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         assert not climate3.initialized_for_setpoint_shift_calculations
 
         climate3.target_temperature.set(23.00)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         assert climate3.initialized_for_setpoint_shift_calculations
 
     async def test_setpoint_shift_mode_autosensing(self):
@@ -434,7 +434,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTValue1Count.to_knx(-4)),
         )
-        await climate_dpt6.process(telegram)
+        climate_dpt6.process(telegram)
         assert climate_dpt6.initialized_for_setpoint_shift_calculations
 
         await climate_dpt6.set_setpoint_shift(1)
@@ -462,7 +462,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTTemperature.to_knx(-4)),
         )
-        await climate_dpt9.process(telegram)
+        climate_dpt9.process(telegram)
         assert climate_dpt9.initialized_for_setpoint_shift_calculations
 
         await climate_dpt9.set_setpoint_shift(1)
@@ -511,11 +511,11 @@ class TestClimate:
         xknx.devices.async_add(climate)
 
         await climate.set_setpoint_shift(4)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         assert not climate.initialized_for_setpoint_shift_calculations
 
         climate.target_temperature.set(23.00)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         assert climate.initialized_for_setpoint_shift_calculations
         assert climate.target_temperature_min == "3"
         assert climate.target_temperature_max == "42"
@@ -544,7 +544,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(30)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
 
         climate.target_temperature.set(23.00)
         assert xknx.telegrams.qsize() == 1
@@ -553,7 +553,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(23.00)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.base_temperature == 20
 
         # First change
@@ -564,13 +564,13 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(40)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         _telegram = xknx.telegrams.get_nowait()
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(24.00)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.target_temperature.value == 24.00
 
         # Second change
@@ -581,13 +581,13 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(35)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         _telegram = xknx.telegrams.get_nowait()
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(23.50)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.target_temperature.value == 23.50
 
         # Test max target temperature
@@ -597,8 +597,8 @@ class TestClimate:
         # third change - limit exceeded, setting to max
         await climate.set_target_temperature(26.50)
         assert xknx.telegrams.qsize() == 2
-        await xknx.devices.process(xknx.telegrams.get_nowait())
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         assert climate.target_temperature_max == 26.00
         assert climate.setpoint_shift == 6
 
@@ -623,7 +623,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(10)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
 
         climate.target_temperature.set(23.00)
         assert xknx.telegrams.qsize() == 1
@@ -632,7 +632,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(23.00)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.base_temperature == 22.0
 
         # First change
@@ -643,13 +643,13 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(0xF1)),
         )  # -15
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         _telegram = xknx.telegrams.get_nowait()
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(20.50)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.target_temperature.value == 20.50
 
         # Second change
@@ -660,13 +660,13 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(0xE2)),
         )  # -30
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         _telegram = xknx.telegrams.get_nowait()
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(19.00)),
         )
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.target_temperature.value == 19.00
 
         # Test min target temperature
@@ -676,8 +676,8 @@ class TestClimate:
         # third change - limit exceeded, setting to min
         await climate.set_target_temperature(15.50)
         assert xknx.telegrams.qsize() == 2
-        await xknx.devices.process(xknx.telegrams.get_nowait())
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         assert climate.target_temperature_min == 16.00
         assert climate.setpoint_shift == -6
 
@@ -700,7 +700,7 @@ class TestClimate:
         await climate.set_setpoint_shift(3)
         assert xknx.telegrams.qsize() == 1
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         # temperature_step is 0.5 -> payload = setpoint_shift * 2
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/3"),
@@ -710,7 +710,7 @@ class TestClimate:
         climate.target_temperature.set(23.00)
         assert xknx.telegrams.qsize() == 1
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(23.00)),
@@ -719,13 +719,13 @@ class TestClimate:
         await climate.set_target_temperature(24.00)
         assert xknx.telegrams.qsize() == 2
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(8)),
         )
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(24.00)),
@@ -757,7 +757,7 @@ class TestClimate:
         await climate.set_target_temperature(21.00)
         assert xknx.telegrams.qsize() == 1
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPT2ByteFloat().to_knx(21.00)),
@@ -769,7 +769,7 @@ class TestClimate:
         await climate.set_setpoint_shift(1)
         assert xknx.telegrams.qsize() == 1
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         # DEFAULT_TEMPERATURE_STEP is 0.1 -> payload = setpoint_shift * 10
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/3"),
@@ -783,14 +783,14 @@ class TestClimate:
         # setpoint_shift and target_temperature are sent to the bus
         assert xknx.telegrams.qsize() == 2
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         # DEFAULT_TEMPERATURE_STEP is 0.1 -> payload = setpoint_shift * 10
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(20)),
         )
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.initialized_for_setpoint_shift_calculations
         assert climate.base_temperature == 20.00
         assert climate.target_temperature.value == 22
@@ -820,7 +820,7 @@ class TestClimate:
         await climate.set_setpoint_shift(0)
         assert xknx.telegrams.qsize() == 1
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.initialized_for_setpoint_shift_calculations
         assert climate.base_temperature == 20.00
         assert _telegram == Telegram(
@@ -831,7 +831,7 @@ class TestClimate:
         await climate.set_target_temperature(19.40)
         assert xknx.telegrams.qsize() == 1
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x87, 0xC4))),
@@ -847,7 +847,7 @@ class TestClimate:
         await climate.set_target_temperature(23.50)
         assert xknx.telegrams.qsize() == 1
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x01, 0x5E))),
@@ -1007,7 +1007,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTTemperature().to_knx(21.34)),
         )
-        await climate.process(telegram)
+        climate.process(telegram)
         assert climate.temperature.value == 21.34
 
     async def test_process_operation_mode(self):
@@ -1024,7 +1024,7 @@ class TestClimate:
                 destination_address=GroupAddress("1/2/5"),
                 payload=GroupValueWrite(DPTHVACMode.to_knx(operation_mode)),
             )
-            await climate_mode.process(telegram)
+            climate_mode.process(telegram)
             assert climate_mode.operation_mode == operation_mode
         for operation_mode in DPT_20102_MODES:
             if operation_mode == HVACOperationMode.AUTO:
@@ -1033,7 +1033,7 @@ class TestClimate:
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueWrite(DPTControllerStatus.to_knx(operation_mode)),
             )
-            await climate_mode.process(telegram)
+            climate_mode.process(telegram)
             assert climate_mode.operation_mode == operation_mode
 
     async def test_process_controller_mode(self):
@@ -1047,7 +1047,7 @@ class TestClimate:
                 destination_address=GroupAddress("1/2/5"),
                 payload=GroupValueWrite(DPTHVACContrMode.to_knx(controller_mode)),
             )
-            await climate_mode.process(telegram)
+            climate_mode.process(telegram)
             assert climate_mode.controller_mode == controller_mode
 
     async def test_process_controller_status_wrong_payload(self):
@@ -1066,7 +1066,7 @@ class TestClimate:
             payload=GroupValueWrite(DPTBinary(1)),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await climate_mode.process(telegram)
+            climate_mode.process(telegram)
             log_mock.assert_called_once()
             updated_cb.assert_not_called()
 
@@ -1086,7 +1086,7 @@ class TestClimate:
             payload=GroupValueWrite(DPTArray((23, 24))),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await climate_mode.process(telegram)
+            climate_mode.process(telegram)
             log_mock.assert_called_once()
             updated_cb.assert_not_called()
 
@@ -1106,7 +1106,7 @@ class TestClimate:
             payload=GroupValueWrite(DPTBinary(1)),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await climate_mode.process(telegram)
+            climate_mode.process(telegram)
             log_mock.assert_called_once()
             updated_cb.assert_not_called()
 
@@ -1126,7 +1126,7 @@ class TestClimate:
             payload=GroupValueWrite(DPTArray((23, 24))),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await climate_mode.process(telegram)
+            climate_mode.process(telegram)
             log_mock.assert_called_once()
             updated_cb.assert_not_called()
 
@@ -1142,7 +1142,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTTemperature().to_knx(21.34)),
         )
-        await climate.process(telegram)
+        climate.process(telegram)
         after_update_callback.assert_called_with(climate)
 
     async def test_process_heat_cool(self):
@@ -1160,14 +1160,14 @@ class TestClimate:
             destination_address=GroupAddress("1/2/14"),
             payload=GroupValueWrite(DPTBinary(False)),
         )
-        await climate_mode.process(telegram)
+        climate_mode.process(telegram)
         assert climate_mode.controller_mode == HVACControllerMode.COOL
 
         telegram = Telegram(
             destination_address=GroupAddress("1/2/14"),
             payload=GroupValueWrite(DPTBinary(True)),
         )
-        await climate_mode.process(telegram)
+        climate_mode.process(telegram)
         assert climate_mode.controller_mode == HVACControllerMode.HEAT
 
     #
@@ -1314,7 +1314,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await climate.process(telegram)
+        climate.process(telegram)
         assert climate.is_on is True
 
         climate_inv = Climate(
@@ -1324,7 +1324,7 @@ class TestClimate:
             destination_address=GroupAddress("1/2/2"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await climate_inv.process(telegram)
+        climate_inv.process(telegram)
         assert climate_inv.is_on is False
 
     async def test_power_on_off(self):
@@ -1335,7 +1335,7 @@ class TestClimate:
 
         await climate.turn_on()
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.is_on is True
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
@@ -1343,7 +1343,7 @@ class TestClimate:
         )
         await climate.turn_off()
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate.is_on is False
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
@@ -1357,7 +1357,7 @@ class TestClimate:
 
         await climate_inv.turn_on()
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate_inv.is_on is True
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
@@ -1365,7 +1365,7 @@ class TestClimate:
         )
         await climate_inv.turn_off()
         _telegram = xknx.telegrams.get_nowait()
-        await xknx.devices.process(_telegram)
+        xknx.devices.process(_telegram)
         assert climate_inv.is_on is False
         assert _telegram == Telegram(
             destination_address=GroupAddress("1/2/2"),
@@ -1395,7 +1395,7 @@ class TestClimate:
         assert climate_command.is_active is None
         assert climate_active_command.is_active is None
         # set active to False
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/1"),
                 payload=GroupValueWrite(DPTBinary(False)),
@@ -1405,7 +1405,7 @@ class TestClimate:
         assert climate_command.is_active is None
         assert climate_active_command.is_active is False
         # set command to 50%
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("2/2/2"),
                 payload=GroupValueWrite(DPTArray((128,))),
@@ -1415,7 +1415,7 @@ class TestClimate:
         assert climate_command.is_active is True
         assert climate_active_command.is_active is False
         # set active to True
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/1"),
                 payload=GroupValueWrite(DPTBinary(True)),
@@ -1425,7 +1425,7 @@ class TestClimate:
         assert climate_command.is_active is True
         assert climate_active_command.is_active is True
         # set command to 0%
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("2/2/2"),
                 payload=GroupValueWrite(DPTArray((0,))),
diff --git a/test/devices_tests/cover_test.py b/test/devices_tests/cover_test.py
index 0c1b755e..eecfc229 100644
--- a/test/devices_tests/cover_test.py
+++ b/test/devices_tests/cover_test.py
@@ -531,7 +531,7 @@ class TestCover:
         assert cover.travelcalculator._travel_to_position == 50
         assert cover.is_opening()
         # process the outgoing telegram to make sure it doesn't overwrite the target position
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.travelcalculator._travel_to_position == 50
         assert xknx.telegrams.qsize() == 0
 
@@ -558,7 +558,7 @@ class TestCover:
         assert cover.travelcalculator._travel_to_position == 80
         assert cover.is_closing()
         # process the outgoing telegram to make sure it doesn't overwrite the target position
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.travelcalculator._travel_to_position == 80
 
         await cover.stop()  # clean up tasks
@@ -672,14 +672,14 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/3"), payload=GroupValueWrite(DPTArray(213))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.current_position() == 84
         assert not cover.is_traveling()
         # state telegram updates current position - we are not moving so this is new state - not moving
         telegram = Telegram(
             GroupAddress("1/2/4"), payload=GroupValueWrite(DPTArray(42))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.current_position() == 16
         assert not cover.is_traveling()
         assert cover.travelcalculator._travel_to_position == 16
@@ -687,7 +687,7 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/3"), payload=GroupValueWrite(DPTArray(255))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.current_position() == 16
         assert cover.is_closing()
         assert cover.travelcalculator._travel_to_position == 100
@@ -695,7 +695,7 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/4"), payload=GroupValueWrite(DPTArray(213))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.current_position() == 84
         assert cover.is_closing()
         assert cover.travelcalculator._travel_to_position == 100
@@ -716,7 +716,7 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/4"), payload=GroupValueWrite(DPTArray(42))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.current_angle() == 16
 
     async def test_process_locked(self):
@@ -731,7 +731,7 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/4"), payload=GroupValueWrite(DPTBinary(1))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.is_locked() is True
 
     async def test_process_up(self):
@@ -748,7 +748,7 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/1"), payload=GroupValueWrite(DPTBinary(0))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.is_opening()
 
         await cover.stop()  # clean up tasks
@@ -767,7 +767,7 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/1"), payload=GroupValueWrite(DPTBinary(1))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert cover.is_closing()
 
         await cover.stop()  # clean up tasks
@@ -787,7 +787,7 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/2"), payload=GroupValueWrite(DPTBinary(1))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert not cover.is_traveling()
 
     async def test_process_short_stop(self):
@@ -805,7 +805,7 @@ class TestCover:
         telegram = Telegram(
             GroupAddress("1/2/2"), payload=GroupValueWrite(DPTBinary(1))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         assert not cover.is_traveling()
 
     async def test_process_callback(self):
@@ -842,17 +842,17 @@ class TestCover:
                 destination_address=GroupAddress(address),
                 payload=GroupValueWrite(payload),
             )
-            await cover.process(telegram)
+            cover.process(telegram)
             after_update_callback.assert_called_with(cover)
             after_update_callback.reset_mock()
         # Stop only when cover is travelling
         telegram = Telegram(
             GroupAddress("1/2/3"), payload=GroupValueWrite(DPTBinary(1))
         )
-        await cover.process(telegram)
+        cover.process(telegram)
         after_update_callback.assert_not_called()
         await cover.set_down()
-        await cover.process(telegram)
+        cover.process(telegram)
         after_update_callback.assert_called_with(cover)
 
         await cover.stop()  # clean up tasks
@@ -991,7 +991,7 @@ class TestCover:
             telegram = Telegram(
                 GroupAddress("1/2/4"), payload=GroupValueWrite(DPTArray(0))
             )
-            await cover.process(telegram)
+            cover.process(telegram)
             await time_travel(0)
             assert callback_mock.call_count == 1
             callback_mock.reset_mock()
@@ -999,7 +999,7 @@ class TestCover:
             telegram = Telegram(
                 GroupAddress("1/2/3"), payload=GroupValueWrite(DPTArray(125))
             )
-            await cover.process(telegram)
+            cover.process(telegram)
             await time_travel(0)
             assert callback_mock.call_count == 1
 
@@ -1014,7 +1014,7 @@ class TestCover:
             telegram = Telegram(
                 GroupAddress("1/2/4"), payload=GroupValueWrite(DPTArray(42))
             )
-            await cover.process(telegram)
+            cover.process(telegram)
             assert callback_mock.call_count == 3
             # next update 1 second after last received state telegram
             mock_time.return_value = 1517000002.0
@@ -1049,7 +1049,7 @@ class TestCover:
             telegram = Telegram(
                 GroupAddress("1/2/4"), payload=GroupValueWrite(DPTArray(0))
             )
-            await cover.process(telegram)
+            cover.process(telegram)
             assert cover.current_position() == 0
             await cover.set_position(50)
             assert cover._periodic_update_task is not None
diff --git a/test/devices_tests/datetime_test.py b/test/devices_tests/datetime_test.py
index f765b68c..aaed7873 100644
--- a/test/devices_tests/datetime_test.py
+++ b/test/devices_tests/datetime_test.py
@@ -35,7 +35,7 @@ class TestDateTime:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x9, 0xD, 0xE))),
         )
-        await datetime.process(telegram)
+        datetime.process(telegram)
         assert datetime.remote_value.value == test_time
 
     #
@@ -143,7 +143,7 @@ class TestDateTime:
         )
         with patch("time.localtime") as mock_time:
             mock_time.return_value = time.struct_time([2017, 1, 7, 9, 13, 14, 6, 0, 0])
-            await datetime.process(telegram_read)
+            datetime.process(telegram_read)
 
         telegram = xknx.telegrams.get_nowait()
         assert telegram == Telegram(
@@ -167,7 +167,7 @@ class TestDateTime:
         telegram_read = Telegram(
             destination_address=GroupAddress("1/2/3"), payload=GroupValueRead()
         )
-        await datetime.process(telegram_read)
+        datetime.process(telegram_read)
 
         telegram = xknx.telegrams.get_nowait()
         assert telegram == Telegram(
diff --git a/test/devices_tests/device_test.py b/test/devices_tests/device_test.py
index 1a88b233..8a10abb7 100644
--- a/test/devices_tests/device_test.py
+++ b/test/devices_tests/device_test.py
@@ -87,33 +87,27 @@ class TestDevice:
         xknx = XKNX()
         device = Device(xknx, "TestDevice")
 
-        with patch(
-            "xknx.devices.Device.process_group_read", new_callable=AsyncMock
-        ) as mock_group_read:
+        with patch("xknx.devices.Device.process_group_read") as mock_group_read:
             telegram = Telegram(
                 destination_address=GroupAddress("1/2/1"), payload=GroupValueRead()
             )
-            await device.process(telegram)
+            device.process(telegram)
             mock_group_read.assert_called_with(telegram)
 
-        with patch(
-            "xknx.devices.Device.process_group_write", new_callable=AsyncMock
-        ) as mock_group_write:
+        with patch("xknx.devices.Device.process_group_write") as mock_group_write:
             telegram = Telegram(
                 destination_address=GroupAddress("1/2/1"),
                 payload=GroupValueWrite(DPTArray((0x01, 0x02))),
             )
-            await device.process(telegram)
+            device.process(telegram)
             mock_group_write.assert_called_with(telegram)
 
-        with patch(
-            "xknx.devices.Device.process_group_response", new_callable=AsyncMock
-        ) as mock_group_response:
+        with patch("xknx.devices.Device.process_group_response") as mock_group_response:
             telegram = Telegram(
                 destination_address=GroupAddress("1/2/1"),
                 payload=GroupValueResponse(DPTArray((0x01, 0x02))),
             )
-            await device.process(telegram)
+            device.process(telegram)
             mock_group_response.assert_called_with(telegram)
 
     async def test_sync_with_wait(self):
@@ -133,18 +127,14 @@ class TestDevice:
         """Test if process_group_write. Nothing really to test here."""
         xknx = XKNX()
         device = Device(xknx, "TestDevice")
-        await device.process_group_write(Telegram(destination_address=GroupAddress(1)))
+        device.process_group_write(Telegram(destination_address=GroupAddress(1)))
 
     async def test_process_group_response(self):
         """Test if process_group_read. Testing if mapped to group_write."""
         xknx = XKNX()
         device = Device(xknx, "TestDevice")
-        with patch(
-            "xknx.devices.Device.process_group_write", new_callable=AsyncMock
-        ) as mock_group_write:
-            await device.process_group_response(
-                Telegram(destination_address=GroupAddress(1))
-            )
+        with patch("xknx.devices.Device.process_group_write") as mock_group_write:
+            device.process_group_response(Telegram(destination_address=GroupAddress(1)))
             mock_group_write.assert_called_with(
                 Telegram(destination_address=GroupAddress(1))
             )
@@ -153,4 +143,4 @@ class TestDevice:
         """Test if process_group_read. Nothing really to test here."""
         xknx = XKNX()
         device = Device(xknx, "TestDevice")
-        await device.process_group_read(Telegram(destination_address=GroupAddress(1)))
+        device.process_group_read(Telegram(destination_address=GroupAddress(1)))
diff --git a/test/devices_tests/devices_test.py b/test/devices_tests/devices_test.py
index 25d233dd..b273d2b2 100644
--- a/test/devices_tests/devices_test.py
+++ b/test/devices_tests/devices_test.py
@@ -139,17 +139,17 @@ class TestDevices:
         xknx.devices.async_add(light1)
         for device in xknx.devices:
             await device.set_on()
-            await xknx.devices.process(xknx.telegrams.get_nowait())
+            xknx.devices.process(xknx.telegrams.get_nowait())
         assert light1.state
 
         device2 = xknx.devices["Living-Room.Light_1"]
         await device2.set_off()
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         assert not light1.state
 
         for device in xknx.devices.devices_by_group_address(GroupAddress("1/6/7")):
             await device.set_on()
-            await xknx.devices.process(xknx.telegrams.get_nowait())
+            xknx.devices.process(xknx.telegrams.get_nowait())
         assert light1.state
 
     #
diff --git a/test/devices_tests/expose_sensor_test.py b/test/devices_tests/expose_sensor_test.py
index 33289a22..65ae10a1 100644
--- a/test/devices_tests/expose_sensor_test.py
+++ b/test/devices_tests/expose_sensor_test.py
@@ -21,7 +21,7 @@ class TestExposeSensor:
         expose_sensor = ExposeSensor(
             xknx, "TestSensor", group_address="1/2/3", value_type="binary"
         )
-        await expose_sensor.process(
+        expose_sensor.process(
             Telegram(
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueWrite(value=DPTBinary(1)),
@@ -38,7 +38,7 @@ class TestExposeSensor:
             xknx, "TestSensor", group_address="1/2/3", value_type="percent"
         )
 
-        await expose_sensor.process(
+        expose_sensor.process(
             Telegram(
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueWrite(DPTArray((0x40,))),
@@ -55,7 +55,7 @@ class TestExposeSensor:
             xknx, "TestSensor", group_address="1/2/3", value_type="temperature"
         )
 
-        await expose_sensor.process(
+        expose_sensor.process(
             Telegram(
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueWrite(DPTArray((0x0C, 0x1A))),
@@ -123,7 +123,7 @@ class TestExposeSensor:
         expose_sensor.sensor_value.value = True
 
         telegram = Telegram(GroupAddress("1/2/3"), payload=GroupValueRead())
-        await expose_sensor.process(telegram)
+        expose_sensor.process(telegram)
         assert xknx.telegrams.qsize() == 1
         telegram = xknx.telegrams.get_nowait()
         assert telegram == Telegram(
@@ -138,7 +138,7 @@ class TestExposeSensor:
             xknx, "TestSensor", value_type="percent", group_address="1/2/3"
         )
 
-        await expose_sensor.process(
+        expose_sensor.process(
             Telegram(
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueWrite(DPTArray((0x40,))),
@@ -146,7 +146,7 @@ class TestExposeSensor:
         )
 
         telegram = Telegram(GroupAddress("1/2/3"), payload=GroupValueRead())
-        await expose_sensor.process(telegram)
+        expose_sensor.process(telegram)
         assert xknx.telegrams.qsize() == 1
         telegram = xknx.telegrams.get_nowait()
         assert telegram == Telegram(
@@ -163,7 +163,7 @@ class TestExposeSensor:
         expose_sensor.sensor_value.value = 21.0
 
         telegram = Telegram(GroupAddress("1/2/3"), payload=GroupValueRead())
-        await expose_sensor.process(telegram)
+        expose_sensor.process(telegram)
         assert xknx.telegrams.qsize() == 1
         telegram = xknx.telegrams.get_nowait()
         assert telegram == Telegram(
@@ -184,7 +184,7 @@ class TestExposeSensor:
         expose_sensor.sensor_value.value = 21.0
 
         telegram = Telegram(GroupAddress("1/2/3"), payload=GroupValueRead())
-        await expose_sensor.process(telegram)
+        expose_sensor.process(telegram)
         assert xknx.telegrams.qsize() == 0
 
     #
@@ -214,7 +214,7 @@ class TestExposeSensor:
         xknx.devices.async_add(expose_sensor)
 
         await expose_sensor.set(21.0)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         after_update_callback.assert_called_with(expose_sensor)
 
     #
@@ -355,7 +355,7 @@ class TestExposeSensor:
         xknx.cemi_handler.send_telegram.reset_mock()
         #   in cooldown with a new value - receiving a read request
         await expose_sensor_cd.set(21)
-        await expose_sensor_cd.process(
+        expose_sensor_cd.process(
             Telegram(GroupAddress("1/2/3"), payload=GroupValueRead())
         )
         await time_travel(0)
diff --git a/test/devices_tests/fan_test.py b/test/devices_tests/fan_test.py
index 03e7f34f..7e2ebf07 100644
--- a/test/devices_tests/fan_test.py
+++ b/test/devices_tests/fan_test.py
@@ -153,7 +153,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(140)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.is_on is True
 
         # A speed of 0 will turn off the fan implicitly if there is no
@@ -166,7 +166,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(0)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.is_on is False
 
         fan_with_switch = Fan(
@@ -182,7 +182,7 @@ class TestFan:
             destination_address=GroupAddress("4/5/6"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await fan_with_switch.process(telegram)
+        fan_with_switch.process(telegram)
         assert fan_with_switch.is_on is True
 
         # A speed of 0 will not turn off the fan implicitly if there is a
@@ -195,7 +195,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(0)),
         )
-        await fan_with_switch.process(telegram)
+        fan_with_switch.process(telegram)
         assert fan_with_switch.is_on is True
 
     #
@@ -254,7 +254,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(140)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         # Setting a speed for a fan that has no dedicated switch GA,
         # should turn on the fan.
         assert fan.is_on is True
@@ -265,7 +265,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(0)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.is_on is False
         assert fan.current_speed == 0
 
@@ -281,7 +281,7 @@ class TestFan:
             payload=GroupValueWrite(DPTBinary(1)),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await fan.process(telegram)
+            fan.process(telegram)
             log_mock.assert_called_once()
             cb_mock.assert_not_called()
 
@@ -305,7 +305,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(140)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         # Setting a speed for a fan with dedicated switch GA,
         # should not turn on the fan
         assert fan.is_on is False
@@ -316,7 +316,7 @@ class TestFan:
             destination_address=GroupAddress("4/5/6"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.is_on is True
         assert fan.current_speed == 55
 
@@ -325,7 +325,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(0)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.is_on is True
         assert fan.current_speed == 0
 
@@ -335,7 +335,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(140)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.is_on is True
         assert fan.current_speed == 55
 
@@ -344,7 +344,7 @@ class TestFan:
             destination_address=GroupAddress("4/5/6"),
             payload=GroupValueWrite(DPTBinary(0)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.is_on is False
         assert fan.current_speed == 55
 
@@ -366,7 +366,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.current_oscillation
 
     async def test_process_fan_payload_invalid_length(self):
@@ -381,7 +381,7 @@ class TestFan:
             payload=GroupValueWrite(DPTArray((23, 24))),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await fan.process(telegram)
+            fan.process(telegram)
             log_mock.assert_called_once()
             cb_mock.assert_not_called()
 
@@ -404,7 +404,7 @@ class TestFan:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray(2)),
         )
-        await fan.process(telegram)
+        fan.process(telegram)
         assert fan.current_speed == 2
 
     def test_has_group_address(self):
diff --git a/test/devices_tests/light_test.py b/test/devices_tests/light_test.py
index 5964057b..1995d081 100644
--- a/test/devices_tests/light_test.py
+++ b/test/devices_tests/light_test.py
@@ -467,7 +467,7 @@ class TestLight:
             assert test_telegram in telegrams
 
         for telegram in telegrams:
-            await light.process(telegram)
+            light.process(telegram)
 
         assert light.state is True
         for color in light._iter_individual_colors():
@@ -519,7 +519,7 @@ class TestLight:
             assert test_telegram in telegrams
 
         for telegram in telegrams:
-            await light.process(telegram)
+            light.process(telegram)
 
         assert light.state is True
         for color in light._iter_individual_colors():
@@ -545,7 +545,7 @@ class TestLight:
             payload=GroupValueWrite(DPTBinary(0)),
         )
 
-        await light.process(telegram)
+        light.process(telegram)
         assert light.state is False
 
     async def test_set_off_individual_color(self):
@@ -598,7 +598,7 @@ class TestLight:
             assert test_telegram in telegrams
 
         for telegram in telegrams:
-            await light.process(telegram)
+            light.process(telegram)
         assert light.state is False
         for color in light._iter_individual_colors():
             assert color.is_on is False
@@ -645,7 +645,7 @@ class TestLight:
             assert test_telegram in telegrams
 
         for telegram in telegrams:
-            await light.process(telegram)
+            light.process(telegram)
         assert light.state is False
         for color in light._iter_individual_colors():
             assert color.is_on is False
@@ -750,7 +750,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray((23, 24, 25))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
         assert light.current_color == ((23, 24, 25), None)
 
     async def test_set_color_not_possible(self):
@@ -808,19 +808,19 @@ class TestLight:
         for test_telegram in test_telegrams:
             assert test_telegram in telegrams
 
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/4"),
                 payload=GroupValueWrite(DPTArray(23)),
             )
         )
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/8"),
                 payload=GroupValueWrite(DPTArray(24)),
             )
         )
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/12"),
                 payload=GroupValueWrite(DPTArray(25)),
@@ -867,7 +867,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray((23, 24, 25, 26, 0, 15))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
         assert light.current_color == ((23, 24, 25), 26)
 
     async def test_set_color_rgbw_not_possible(self):
@@ -939,25 +939,25 @@ class TestLight:
         for test_telegram in test_telegrams:
             assert test_telegram in telegrams
 
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/4"),
                 payload=GroupValueWrite(DPTArray(23)),
             )
         )
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/8"),
                 payload=GroupValueWrite(DPTArray(24)),
             )
         )
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/12"),
                 payload=GroupValueWrite(DPTArray(25)),
             )
         )
-        await xknx.devices.process(
+        xknx.devices.process(
             Telegram(
                 destination_address=GroupAddress("1/1/16"),
                 payload=GroupValueWrite(DPTArray(26)),
@@ -1017,14 +1017,14 @@ class TestLight:
             destination_address=GroupAddress("1/2/4"),
             payload=GroupValueWrite(DPTArray((0xFE,))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
 
         telegram = xknx.telegrams.get_nowait()
         assert telegram == Telegram(
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray((0xFC,))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
 
         assert light.current_hs_color == (359, 99)
 
@@ -1036,7 +1036,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/4"),
             payload=GroupValueWrite(DPTArray((0x0D,))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
 
         await light.set_hs_color((18, 3))
         assert xknx.telegrams.qsize() == 1
@@ -1045,7 +1045,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray((0x08,))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
 
         # call set_hs_color with current color shall trigger both values
         await light.set_hs_color((18, 3))
@@ -1056,14 +1056,14 @@ class TestLight:
             destination_address=GroupAddress("1/2/4"),
             payload=GroupValueWrite(DPTArray((0x0D,))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
 
         telegram = xknx.telegrams.get_nowait()
         assert telegram == Telegram(
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray((0x08,))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
 
     async def test_set_hs_color_not_possible(self):
         """Test setting HS value of a light not supporting it."""
@@ -1105,7 +1105,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/4"),
             payload=GroupValueWrite(DPTArray((0x85, 0x1E, 0x4F, 0x5C, 0x19, 0x03))),
         )
-        await xknx.devices.process(telegram)
+        xknx.devices.process(telegram)
         assert light.current_xyy_color == XYYColor((0.52, 0.31), 25)
 
     async def test_set_xyy_color_not_possible(self):
@@ -1251,14 +1251,14 @@ class TestLight:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.state is True
 
         telegram = Telegram(
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(0)),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.state is False
 
     async def test_process_color_switch(self):
@@ -1288,14 +1288,14 @@ class TestLight:
             destination_address=GroupAddress("1/1/2"),
             payload=GroupValueWrite(DPTBinary(True)),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.state is True
 
         telegram = Telegram(
             destination_address=GroupAddress("1/1/2"),
             payload=GroupValueWrite(DPTBinary(False)),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.state is False
 
     async def test_process_switch_callback(self):
@@ -1317,7 +1317,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await light.process(telegram)
+        light.process(telegram)
         after_update_callback.assert_called_with(light)
 
     async def test_process_dimm(self):
@@ -1337,7 +1337,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray(23)),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.current_brightness == 23
 
     async def test_process_dimm_wrong_payload(self):
@@ -1358,7 +1358,7 @@ class TestLight:
             payload=GroupValueWrite(DPTBinary(1)),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await light.process(telegram)
+            light.process(telegram)
             log_mock.assert_called_once()
             cb_mock.assert_not_called()
 
@@ -1380,7 +1380,7 @@ class TestLight:
             payload=GroupValueWrite(DPTArray((23, 24))),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await light.process(telegram)
+            light.process(telegram)
             log_mock.assert_called_once()
             cb_mock.assert_not_called()
 
@@ -1400,7 +1400,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray((23, 24, 25))),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.current_color == ((23, 24, 25), None)
 
     async def test_process_individual_color(self):
@@ -1442,7 +1442,7 @@ class TestLight:
         ]
 
         for telegram in telegrams:
-            await light.process(telegram)
+            light.process(telegram)
         assert light.current_color == ((42, 43, 44), None)
 
     async def test_process_color_rgbw(self):
@@ -1462,7 +1462,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray((23, 24, 25, 26, 0, 15))),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.current_color == ((23, 24, 25), 26)
 
     async def test_process_individual_color_rgbw(self):
@@ -1495,7 +1495,7 @@ class TestLight:
             destination_address=GroupAddress("1/1/16"),
             payload=GroupValueWrite(DPTArray(42)),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.current_color == (None, 42)
 
     async def test_process_individual_color_debouncer(self, time_travel):
@@ -1558,16 +1558,16 @@ class TestLight:
             payload=GroupValueWrite(DPTArray(50)),
         )
 
-        await xknx.devices.process(red)
+        xknx.devices.process(red)
         rgb_callback.assert_not_called()
         rgbw_callback.assert_not_called()
-        await xknx.devices.process(green)
+        xknx.devices.process(green)
         rgb_callback.assert_not_called()
         rgbw_callback.assert_not_called()
-        await xknx.devices.process(blue)
+        xknx.devices.process(blue)
         rgb_callback.assert_called_once()
         rgbw_callback.assert_not_called()
-        await xknx.devices.process(white)
+        xknx.devices.process(white)
         rgbw_callback.assert_called_once()
 
         assert rgb_light.current_color == ((42, 43, 44), None)
@@ -1576,10 +1576,10 @@ class TestLight:
         rgb_callback.reset_mock()
         rgbw_callback.reset_mock()
         # second time with only 2 telegrams
-        await xknx.devices.process(red)
+        xknx.devices.process(red)
         rgb_callback.assert_not_called()
         rgbw_callback.assert_not_called()
-        await xknx.devices.process(green)
+        xknx.devices.process(green)
         rgb_callback.assert_not_called()
         rgbw_callback.assert_not_called()
         await time_travel(Light.DEBOUNCE_TIMEOUT / 2)
@@ -1606,7 +1606,7 @@ class TestLight:
         )
         assert light.current_hs_color is None
         # initialize hue
-        await light.process(
+        light.process(
             Telegram(
                 destination_address=GroupAddress("1/4/4"),
                 payload=GroupValueWrite(DPTArray((0x2E,))),
@@ -1614,7 +1614,7 @@ class TestLight:
         )
         assert light.current_hs_color is None
         # initialize saturation
-        await light.process(
+        light.process(
             Telegram(
                 destination_address=GroupAddress("1/4/5"),
                 payload=GroupValueWrite(DPTArray((0x55,))),
@@ -1633,7 +1633,7 @@ class TestLight:
         )
         assert light.current_xyy_color is None
         # initial with invalid brightness
-        await light.process(
+        light.process(
             Telegram(
                 destination_address=GroupAddress("1/2/5"),
                 payload=GroupValueWrite(DPTArray((0x2E, 0x14, 0x40, 0x00, 0x55, 0x02))),
@@ -1641,7 +1641,7 @@ class TestLight:
         )
         assert light.current_xyy_color == XYYColor((0.18, 0.25), None)
         # add valid brightness
-        await light.process(
+        light.process(
             Telegram(
                 destination_address=GroupAddress("1/2/5"),
                 payload=GroupValueWrite(DPTArray((0x2E, 0x14, 0x40, 0x00, 0x55, 0x03))),
@@ -1649,7 +1649,7 @@ class TestLight:
         )
         assert light.current_xyy_color == XYYColor((0.18, 0.25), 85)
         # invalid color
-        await light.process(
+        light.process(
             Telegram(
                 destination_address=GroupAddress("1/2/5"),
                 payload=GroupValueWrite(DPTArray((0xD1, 0xEB, 0xB0, 0xA3, 0xA5, 0x01))),
@@ -1657,7 +1657,7 @@ class TestLight:
         )
         assert light.current_xyy_color == XYYColor((0.18, 0.25), 165)
         # both valid
-        await light.process(
+        light.process(
             Telegram(
                 destination_address=GroupAddress("1/2/5"),
                 payload=GroupValueWrite(DPTArray((0xD1, 0xEB, 0xB0, 0xA3, 0xA5, 0x03))),
@@ -1665,7 +1665,7 @@ class TestLight:
         )
         assert light.current_xyy_color == XYYColor((0.82, 0.69), 165)
         # invalid brightness
-        await light.process(
+        light.process(
             Telegram(
                 destination_address=GroupAddress("1/2/5"),
                 payload=GroupValueWrite(DPTArray((0x2E, 0x14, 0x40, 0x00, 0x00, 0x02))),
@@ -1688,7 +1688,7 @@ class TestLight:
             destination_address=GroupAddress("1/2/5"),
             payload=GroupValueWrite(DPTArray(23)),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.current_tunable_white == 23
 
     async def test_process_tunable_white_wrong_payload(self):
@@ -1707,7 +1707,7 @@ class TestLight:
             payload=GroupValueWrite(DPTBinary(1)),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await light.process(telegram)
+            light.process(telegram)
             log_mock.assert_called_once()
             cb_mock.assert_not_called()
 
@@ -1727,7 +1727,7 @@ class TestLight:
             payload=GroupValueWrite(DPTArray((23, 24))),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await light.process(telegram)
+            light.process(telegram)
             log_mock.assert_called_once()
             cb_mock.assert_not_called()
 
@@ -1753,7 +1753,7 @@ class TestLight:
                 )
             ),
         )
-        await light.process(telegram)
+        light.process(telegram)
         assert light.current_color_temperature == 4000
 
     async def test_process_color_temperature_wrong_payload(self):
@@ -1772,7 +1772,7 @@ class TestLight:
             payload=GroupValueWrite(DPTBinary(1)),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await light.process(telegram)
+            light.process(telegram)
             log_mock.assert_called_once()
             cb_mock.assert_not_called()
 
@@ -1792,7 +1792,7 @@ class TestLight:
             payload=GroupValueWrite(DPTArray(23)),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await light.process(telegram)
+            light.process(telegram)
             log_mock.assert_called_once()
             cb_mock.assert_not_called()
 
diff --git a/test/devices_tests/notification_test.py b/test/devices_tests/notification_test.py
index 2b53a139..e052b19d 100644
--- a/test/devices_tests/notification_test.py
+++ b/test/devices_tests/notification_test.py
@@ -39,14 +39,14 @@ class TestNotification:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTString().to_knx("Ein Prosit!")),
         )
-        await notification.process(telegram_set)
+        notification.process(telegram_set)
         assert notification.message == "Ein Prosit!"
 
         telegram_unset = Telegram(
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTString().to_knx("")),
         )
-        await notification.process(telegram_unset)
+        notification.process(telegram_unset)
         assert notification.message == ""
 
     async def test_process_callback(self):
@@ -61,7 +61,7 @@ class TestNotification:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTString().to_knx("Ein Prosit!")),
         )
-        await notification.process(telegram_set)
+        notification.process(telegram_set)
         after_update_callback.assert_called_with(notification)
 
     async def test_process_payload_invalid_length(self):
@@ -79,7 +79,7 @@ class TestNotification:
             payload=GroupValueWrite(DPTArray((23, 24))),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await notification.process(telegram)
+            notification.process(telegram)
             log_mock.assert_called_once()
             after_update_callback.assert_not_called()
 
@@ -98,7 +98,7 @@ class TestNotification:
             payload=GroupValueWrite(DPTBinary(1)),
         )
         with patch("logging.Logger.warning") as log_mock:
-            await notification.process(telegram)
+            notification.process(telegram)
             log_mock.assert_called_once()
             after_update_callback.assert_not_called()
 
@@ -130,11 +130,11 @@ class TestNotification:
             destination_address=GroupAddress("1/1/1"), payload=GroupValueRead()
         )
         # verify no response when respond_to_read is False
-        await non_responding.process(read_telegram)
+        non_responding.process(read_telegram)
         assert xknx.telegrams.qsize() == 0
 
         # verify response when respond_to_read is True
-        await responding.process(read_telegram)
+        responding.process(read_telegram)
         assert xknx.telegrams.qsize() == 1
         response = xknx.telegrams.get_nowait()
         assert response == Telegram(
diff --git a/test/devices_tests/numeric_value_test.py b/test/devices_tests/numeric_value_test.py
index a74c988a..b180a064 100644
--- a/test/devices_tests/numeric_value_test.py
+++ b/test/devices_tests/numeric_value_test.py
@@ -94,7 +94,7 @@ class TestNumericValue:
             group_address="1/2/3",
             value_type=value_type,
         )
-        await sensor.process(
+        sensor.process(
             Telegram(
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueWrite(value=raw_payload),
@@ -140,11 +140,11 @@ class TestNumericValue:
             destination_address=GroupAddress("1/1/1"), payload=GroupValueRead()
         )
         # verify no response when respond is False
-        await non_responding.process(read_telegram)
+        non_responding.process(read_telegram)
         assert xknx.telegrams.qsize() == 0
 
         # verify response when respond is True
-        await responding.process(read_telegram)
+        responding.process(read_telegram)
         assert xknx.telegrams.qsize() == 1
         response = xknx.telegrams.get_nowait()
         assert response == Telegram(
@@ -152,19 +152,19 @@ class TestNumericValue:
             payload=GroupValueResponse(DPTArray((0x00, 0x00, 0x01, 0x00))),
         )
         # verify no response when GroupValueRead request is not for group_address
-        await responding_multiple.process(read_telegram)
+        responding_multiple.process(read_telegram)
         assert xknx.telegrams.qsize() == 1
         response = xknx.telegrams.get_nowait()
         assert response == Telegram(
             destination_address=GroupAddress("1/1/1"),
             payload=GroupValueResponse(DPTArray((0x00, 0x00, 0x01, 0x00))),
         )
-        await responding_multiple.process(
+        responding_multiple.process(
             Telegram(
                 destination_address=GroupAddress("2/2/2"), payload=GroupValueRead()
             )
         )
-        await responding_multiple.process(
+        responding_multiple.process(
             Telegram(
                 destination_address=GroupAddress("3/3/3"), payload=GroupValueRead()
             )
@@ -235,7 +235,7 @@ class TestNumericValue:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x06, 0xA0))),
         )
-        await sensor.process(telegram)
+        sensor.process(telegram)
         assert sensor.sensor_value.value == 16.96
         assert sensor.sensor_value.telegram.payload.value == DPTArray((0x06, 0xA0))
         assert sensor.resolve_state() == 16.96
@@ -254,12 +254,12 @@ class TestNumericValue:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x01, 0x02))),
         )
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_called_with(sensor)
         assert sensor.last_telegram == telegram
         # consecutive telegrams with same payload shall only trigger one callback
         after_update_callback.reset_mock()
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_not_called()
 
     async def test_process_callback_always(self):
@@ -280,12 +280,12 @@ class TestNumericValue:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x01, 0x02))),
         )
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_called_with(sensor)
         assert sensor.last_telegram == telegram
         # every telegram shall trigger callback
         after_update_callback.reset_mock()
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_called_with(sensor)
 
     async def test_process_callback_set(self):
@@ -300,7 +300,7 @@ class TestNumericValue:
         num_value.register_device_updated_cb(after_update_callback)
 
         await num_value.set(21.0)
-        await xknx.devices.process(xknx.telegrams.get_nowait())
+        xknx.devices.process(xknx.telegrams.get_nowait())
         after_update_callback.assert_called_with(num_value)
 
     def test_string(self):
diff --git a/test/devices_tests/raw_value_test.py b/test/devices_tests/raw_value_test.py
index bf6053a6..fa1de3d2 100644
--- a/test/devices_tests/raw_value_test.py
+++ b/test/devices_tests/raw_value_test.py
@@ -68,7 +68,7 @@ class TestRawValue:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(value=raw_payload),
         )
-        await raw_value.process(telegram)
+        raw_value.process(telegram)
         assert raw_value.resolve_state() == expected_state
         assert raw_value.last_telegram == telegram
 
@@ -109,11 +109,11 @@ class TestRawValue:
             destination_address=GroupAddress("1/1/1"), payload=GroupValueRead()
         )
         # verify no response when respond is False
-        await non_responding.process(read_telegram)
+        non_responding.process(read_telegram)
         assert xknx.telegrams.qsize() == 0
 
         # verify response when respond is True
-        await responding.process(read_telegram)
+        responding.process(read_telegram)
         assert xknx.telegrams.qsize() == 1
         response = xknx.telegrams.get_nowait()
         assert response == Telegram(
@@ -121,19 +121,19 @@ class TestRawValue:
             payload=GroupValueResponse(DPTArray((0x01, 0x00))),
         )
         # verify no response when GroupValueRead request is not for group_address
-        await responding_multiple.process(read_telegram)
+        responding_multiple.process(read_telegram)
         assert xknx.telegrams.qsize() == 1
         response = xknx.telegrams.get_nowait()
         assert response == Telegram(
             destination_address=GroupAddress("1/1/1"),
             payload=GroupValueResponse(DPTArray((0x01, 0x00))),
         )
-        await responding_multiple.process(
+        responding_multiple.process(
             Telegram(
                 destination_address=GroupAddress("2/2/2"), payload=GroupValueRead()
             )
         )
-        await responding_multiple.process(
+        responding_multiple.process(
             Telegram(
                 destination_address=GroupAddress("3/3/3"), payload=GroupValueRead()
             )
@@ -161,12 +161,12 @@ class TestRawValue:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x01, 0x02))),
         )
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_called_with(sensor)
         assert sensor.last_telegram == telegram
         # consecutive telegrams with same payload shall only trigger one callback
         after_update_callback.reset_mock()
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_not_called()
 
     async def test_process_callback_always(self):
@@ -187,12 +187,12 @@ class TestRawValue:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x01, 0x02))),
         )
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_called_with(sensor)
         assert sensor.last_telegram == telegram
         # every telegram shall trigger callback
         after_update_callback.reset_mock()
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_called_with(sensor)
 
     #
diff --git a/test/devices_tests/sensor_test.py b/test/devices_tests/sensor_test.py
index 518eec40..7487b7e8 100644
--- a/test/devices_tests/sensor_test.py
+++ b/test/devices_tests/sensor_test.py
@@ -684,7 +684,7 @@ class TestSensor:
             group_address_state="1/2/3",
             value_type=value_type,
         )
-        await sensor.process(
+        sensor.process(
             Telegram(
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueWrite(value=raw_payload),
@@ -716,18 +716,18 @@ class TestSensor:
             payload=GroupValueResponse(payload),
         )
         # verify not called when always_callback is False
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_not_called()
         after_update_callback.reset_mock()
 
         sensor.always_callback = True
         # verify called when always_callback is True
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_called_once()
         after_update_callback.reset_mock()
 
         # verify not called when processing read responses
-        await sensor.process(response_telegram)
+        sensor.process(response_telegram)
         after_update_callback.assert_not_called()
 
     #
@@ -772,7 +772,7 @@ class TestSensor:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x06, 0xA0))),
         )
-        await sensor.process(telegram)
+        sensor.process(telegram)
         assert sensor.sensor_value.value == 16.96
         assert sensor.sensor_value.telegram.payload.value == DPTArray((0x06, 0xA0))
         assert sensor.resolve_state() == 16.96
@@ -793,6 +793,6 @@ class TestSensor:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTArray((0x01, 0x02))),
         )
-        await sensor.process(telegram)
+        sensor.process(telegram)
         after_update_callback.assert_called_with(sensor)
         assert sensor.last_telegram == telegram
diff --git a/test/devices_tests/switch_test.py b/test/devices_tests/switch_test.py
index 82cd6185..2add352c 100644
--- a/test/devices_tests/switch_test.py
+++ b/test/devices_tests/switch_test.py
@@ -68,20 +68,20 @@ class TestSwitch:
             payload=GroupValueWrite(DPTBinary(0)),
         )
 
-        await switch1.process(telegram_on)
+        switch1.process(telegram_on)
         assert switch1.state is True
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
-        await switch1.process(telegram_off)
+        switch1.process(telegram_off)
         assert switch1.state is False
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
         # test setting switch2 to False with first telegram
-        await switch2.process(telegram_off)
+        switch2.process(telegram_off)
         assert switch2.state is False
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
-        await switch2.process(telegram_on)
+        switch2.process(telegram_on)
         assert switch2.state is True
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
@@ -118,20 +118,20 @@ class TestSwitch:
             payload=GroupValueResponse(DPTBinary(0)),
         )
 
-        await switch1.process(telegram_on)
+        switch1.process(telegram_on)
         assert switch1.state is True
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
-        await switch1.process(telegram_off)
+        switch1.process(telegram_off)
         assert switch1.state is False
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
         # test setting switch2 to False with first telegram
-        await switch2.process(telegram_off)
+        switch2.process(telegram_off)
         assert switch2.state is False
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
-        await switch2.process(telegram_on)
+        switch2.process(telegram_on)
         assert switch2.state is True
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
@@ -151,9 +151,9 @@ class TestSwitch:
             payload=GroupValueWrite(DPTBinary(1)),
         )
 
-        await switch.process(telegram_inv_on)
+        switch.process(telegram_inv_on)
         assert switch.state is True
-        await switch.process(telegram_inv_off)
+        switch.process(telegram_inv_off)
         assert switch.state is False
 
     async def test_process_reset_after(self, time_travel):
@@ -168,12 +168,12 @@ class TestSwitch:
             payload=GroupValueWrite(DPTBinary(1)),
         )
 
-        await switch.process(telegram_on)
+        switch.process(telegram_on)
         assert switch.state
         assert xknx.telegrams.qsize() == 0
         await time_travel(reset_after_sec)
         assert xknx.telegrams.qsize() == 1
-        await switch.process(xknx.telegrams.get_nowait())
+        switch.process(xknx.telegrams.get_nowait())
         assert not switch.state
 
     async def test_process_reset_after_cancel_existing(self, time_travel):
@@ -188,12 +188,12 @@ class TestSwitch:
             payload=GroupValueResponse(DPTBinary(1)),
         )
 
-        await switch.process(telegram_on)
+        switch.process(telegram_on)
         assert switch.state
         assert xknx.telegrams.qsize() == 0
         await time_travel(reset_after_sec / 2)
         # half way through the reset timer
-        await switch.process(telegram_on)
+        switch.process(telegram_on)
         assert switch.state
 
         await time_travel(reset_after_sec / 2)
@@ -209,7 +209,7 @@ class TestSwitch:
                 destination_address=GroupAddress("1/2/3"),
                 payload=GroupValueResponse(DPTBinary(1)),
             )
-            await switch.process(telegram_on)
+            switch.process(telegram_on)
             assert switch.state
             assert switch._reset_task is not None
             xknx.devices.async_remove(switch)
@@ -228,7 +228,7 @@ class TestSwitch:
             destination_address=GroupAddress("1/2/3"),
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await switch.process(telegram)
+        switch.process(telegram)
 
         after_update_callback.assert_called_with(switch)
 
@@ -266,11 +266,11 @@ class TestSwitch:
             destination_address=GroupAddress("1/1/1"), payload=GroupValueRead()
         )
         # verify no response when respond is False
-        await non_responding.process(read_telegram)
+        non_responding.process(read_telegram)
         assert xknx.telegrams.qsize() == 0
 
         # verify response when respond is True
-        await responding.process(read_telegram)
+        responding.process(read_telegram)
         assert xknx.telegrams.qsize() == 1
         response = xknx.telegrams.get_nowait()
         assert response == Telegram(
@@ -278,19 +278,19 @@ class TestSwitch:
             payload=GroupValueResponse(DPTBinary(True)),
         )
         # verify no response when GroupValueRead request is not for group_address
-        await responding_multiple.process(read_telegram)
+        responding_multiple.process(read_telegram)
         assert xknx.telegrams.qsize() == 1
         response = xknx.telegrams.get_nowait()
         assert response == Telegram(
             destination_address=GroupAddress("1/1/1"),
             payload=GroupValueResponse(DPTBinary(True)),
         )
-        await responding_multiple.process(
+        responding_multiple.process(
             Telegram(
                 destination_address=GroupAddress("2/2/2"), payload=GroupValueRead()
             )
         )
-        await responding_multiple.process(
+        responding_multiple.process(
             Telegram(
                 destination_address=GroupAddress("3/3/3"), payload=GroupValueRead()
             )
@@ -396,11 +396,11 @@ class TestSwitch:
             payload=GroupValueWrite(DPTBinary(0)),
         )
 
-        await switch1.process(telegram_on_passive)
+        switch1.process(telegram_on_passive)
         assert switch1.state is True
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
-        await switch1.process(telegram_off_passive)
+        switch1.process(telegram_off_passive)
         assert switch1.state is False
         callback_mock.assert_called_once()
         callback_mock.reset_mock()
diff --git a/test/devices_tests/weather_test.py b/test/devices_tests/weather_test.py
index 4a21ebd2..883f3f0e 100644
--- a/test/devices_tests/weather_test.py
+++ b/test/devices_tests/weather_test.py
@@ -18,7 +18,7 @@ class TestWeather:
         xknx = XKNX()
         weather = Weather(name="weather", xknx=xknx, group_address_temperature="1/3/4")
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/4"),
                 payload=GroupValueWrite(value=DPTArray((0x19, 0xA))),
@@ -43,28 +43,28 @@ class TestWeather:
             group_address_temperature="1/4/4",
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/5"),
                 payload=GroupValueWrite(value=DPTArray((0x7C, 0x5E))),
             )
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/7"),
                 payload=GroupValueWrite(value=DPTArray((0x7C, 0x5C))),
             )
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/6"),
                 payload=GroupValueWrite(value=DPTArray((0x7C, 0x5A))),
             )
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/8"),
                 payload=GroupValueWrite(value=DPTArray((0x7C, 0x5A))),
@@ -92,7 +92,7 @@ class TestWeather:
         xknx = XKNX()
         weather = Weather(name="weather", xknx=xknx, group_address_air_pressure="1/3/4")
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/4"),
                 payload=GroupValueWrite(value=DPTArray((0x6C, 0xAD))),
@@ -108,7 +108,7 @@ class TestWeather:
         xknx = XKNX()
         weather = Weather(name="weather", xknx=xknx, group_address_humidity="1/2/4")
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/2/4"),
                 payload=GroupValueWrite(value=DPTArray((0x7E, 0xE1))),
@@ -126,7 +126,7 @@ class TestWeather:
             name="weather", xknx=xknx, group_address_wind_speed="1/3/8"
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/8"),
                 payload=GroupValueWrite(value=DPTArray((0x7D, 0x98))),
@@ -144,7 +144,7 @@ class TestWeather:
             name="weather", xknx=xknx, group_address_wind_bearing="1/3/8"
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/8"),
                 payload=GroupValueWrite(value=DPTArray((0xBF,))),
@@ -225,7 +225,7 @@ class TestWeather:
             group_address_brightness_south="1/3/6",
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/6"),
                 payload=GroupValueWrite(value=DPTArray((0x46, 0x45))),
@@ -250,7 +250,7 @@ class TestWeather:
             group_address_brightness_west="1/3/7",
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/6"),
                 payload=GroupValueWrite(value=DPTArray((0x7C, 0x5C))),
@@ -273,7 +273,7 @@ class TestWeather:
             group_address_brightness_west="1/3/7",
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/6"),
                 payload=GroupValueWrite(value=DPTArray((0x7C, 0x5C))),
@@ -297,7 +297,7 @@ class TestWeather:
             group_address_brightness_west="1/3/7",
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/6"),
                 payload=GroupValueWrite(value=DPTArray((0x46, 0x45))),
@@ -318,7 +318,7 @@ class TestWeather:
             name="weather", xknx=xknx, group_address_day_night="1/3/20"
         )
 
-        await weather.process(
+        weather.process(
             Telegram(
                 destination_address=GroupAddress("1/3/20"),
                 payload=GroupValueWrite(value=DPTBinary(0)),
diff --git a/test/str_test.py b/test/str_test.py
index b8e70b35..93a17f40 100644
--- a/test/str_test.py
+++ b/test/str_test.py
@@ -267,7 +267,7 @@ class TestStringRepresentations:
             == '<Notification name="Alarm" message=<1/2/3, 1/2/4, [], None /> />'
         )
         await notification.set("Einbrecher im Haus")
-        await notification.process(xknx.telegrams.get_nowait())
+        notification.process(xknx.telegrams.get_nowait())
         assert (
             str(notification) == '<Notification name="Alarm" '
             "message=<1/2/3, 1/2/4, [], 'Einbrecher im ' /> />"
@@ -298,7 +298,7 @@ class TestStringRepresentations:
             direction=TelegramDirection.INCOMING,
             payload=GroupValueWrite(DPTArray(0x40)),
         )
-        await sensor.process_group_write(telegram)
+        sensor.process_group_write(telegram)
         assert (
             str(sensor)
             == '<Sensor name="MeinSensor" sensor=<None, 1/2/3, [], 25 /> value=25 unit="%"/>'
@@ -315,7 +315,7 @@ class TestStringRepresentations:
             == '<ExposeSensor name="MeinSensor" sensor=<1/2/3, None, [], None /> value=None unit="%"/>'
         )
         await sensor.set(25)
-        await sensor.process(xknx.telegrams.get_nowait())
+        sensor.process(xknx.telegrams.get_nowait())
         assert (
             str(sensor)
             == '<ExposeSensor name="MeinSensor" sensor=<1/2/3, None, [], 25 /> value=25 unit="%"/>'
@@ -368,7 +368,7 @@ class TestStringRepresentations:
             direction=TelegramDirection.INCOMING,
             payload=GroupValueWrite(DPTBinary(1)),
         )
-        await weather.process_group_write(telegram)
+        weather.process_group_write(telegram)
 
         assert (
             str(weather)