diff --git a/plugwise/legacy/smile.py b/plugwise/legacy/smile.py
index 02bd74abf..7cd22032c 100644
--- a/plugwise/legacy/smile.py
+++ b/plugwise/legacy/smile.py
@@ -171,15 +171,9 @@ async def set_preset(self, _: str, preset: str) -> None:
             raise PlugwiseError("Plugwise: invalid preset.")
 
         locator = f'rule/directives/when/then[@icon="{preset}"].../.../...'
-        rule = self._domain_objects.find(locator)
-        data = f'''
-            <rules>
-                <rule id="{rule.attrib["id"]}">
-                    <active>true</active>
-                </rule>
-            </rules>
-        '''
-        await self.call_request(RULES, method="put", data=data.strip())
+        rule_id = self._domain_objects.find(locator).attrib["id"]
+        data = f"<rules><rule id='{rule_id}'><active>true</active></rule></rules>"
+        await self.call_request(RULES, method="put", data=data)
 
     async def set_regulation_mode(self, mode: str) -> None:
         """Set-function placeholder for legacy devices."""
@@ -224,17 +218,17 @@ async def set_schedule_state(
         for rule in self._domain_objects.findall(locator):
             template_id = rule.attrib["id"]
 
-        data = f'''
-            <rules>
-                <rule id="{schedule_rule_id}">
-                    <name><![CDATA[{name}]]></name>
-                    <template id="{template_id}" />
-                    <active>{new_state}</active>
-                </rule>
-            </rules>
-        '''
+        data = (
+            "<rules>"
+            f"<rule id='{schedule_rule_id}'>"
+            f"<name><![CDATA[{name}]]></name>"
+            f"<template id='{template_id}' />"
+            f"<active>{new_state}</active>"
+            "</rule>"
+            "</rules>"
+        )
         uri = f"{RULES};id={schedule_rule_id}"
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def set_switch_state(
         self, appl_id: str, members: list[str] | None, model: str, state: str
@@ -258,21 +252,21 @@ async def set_switch_state(
             appliance = self._appliances.find(f'appliance[@id="{appl_id}"]')
             appl_name = appliance.find("name").text
             appl_type = appliance.find("type").text
-            data = f'''
-                <appliances>
-                    <appliance id="{appl_id}">
-                        <name><![CDATA[{appl_name}]]></name>
-                        <description><![CDATA[]]></description>
-                        <type><![CDATA[{appl_type}]]></type>
-                        <{switch.actuator}>
-                            <{switch.func_type}>
-                                <lock>{state}</lock>
-                            </{switch.func_type}>
-                        </{switch.actuator}>
-                    </appliance>
-                </appliances>
-            '''
-            await self.call_request(APPLIANCES, method="post", data=data.strip())
+            data = (
+                "<appliances>"
+                f"<appliance id='{appl_id}'>"
+                f"<name><![CDATA[{appl_name}]]></name>"
+                f"<description><![CDATA[]]></description>"
+                f"<type><![CDATA[{appl_type}]]></type>"
+                f"<{switch.actuator}>"
+                f"<{switch.func_type}>"
+                f"<lock>{state}</lock>"
+                f"</{switch.func_type}>"
+                f"</{switch.actuator}>"
+                "</appliance>"
+                "</appliances>"
+            )
+            await self.call_request(APPLIANCES, method="post", data=data)
             return
 
         # Handle group of switches
@@ -317,13 +311,13 @@ async def set_temperature(self, _: str, items: dict[str, float]) -> None:
             )  # pragma: no cover"
 
         temperature = str(setpoint)
-        data = f"""
-            <thermostat_functionality>
-                <setpoint>{temperature}</setpoint>
-            </thermostat_functionality>
-        """
+        data = (
+            "<thermostat_functionality>"
+            f"<setpoint>{temperature}</setpoint>"
+            "</thermostat_functionality>"
+        )
         uri = self._thermostat_uri()
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def call_request(self, uri: str, **kwargs: Any) -> None:
         """ConnectionFailedError wrapper for calling request()."""
diff --git a/plugwise/smile.py b/plugwise/smile.py
index d90ce89fe..aec1a6fa8 100644
--- a/plugwise/smile.py
+++ b/plugwise/smile.py
@@ -174,13 +174,13 @@ async def set_number(
         if thermostat_id is None:
             raise PlugwiseError(f"Plugwise: cannot change setpoint, {key} not found.")
 
-        data = f"""
-            <thermostat_functionality>
-                <setpoint>{temp}</setpoint>
-            </thermostat_functionality>
-        """
+        data = (
+            "<thermostat_functionality>"
+            f"<setpoint>{temp}</setpoint>"
+            "</thermostat_functionality>"
+        )
         uri = f"{APPLIANCES};id={self._heater_id}/thermostat;id={thermostat_id}"
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def set_offset(self, dev_id: str, offset: float) -> None:
         """Set the Temperature offset for thermostats that support this feature."""
@@ -190,13 +190,9 @@ async def set_offset(self, dev_id: str, offset: float) -> None:
             )
 
         value = str(offset)
-        data = f"""
-            <offset_functionality>
-                <offset>{value}</offset>
-            </offset_functionality>
-        """
+        data = f"<offset_functionality><offset>{value}</offset></offset_functionality>"
         uri = f"{APPLIANCES};id={dev_id}/offset;type=temperature_offset"
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def set_preset(self, loc_id: str, preset: str) -> None:
         """Set the given Preset on the relevant Thermostat - from LOCATIONS."""
@@ -208,17 +204,17 @@ async def set_preset(self, loc_id: str, preset: str) -> None:
         current_location = self._domain_objects.find(f'location[@id="{loc_id}"]')
         location_name = current_location.find("name").text
         location_type = current_location.find("type").text
-        data = f'''
-            <locations>
-                <location id="{loc_id}">
-                    <name>{location_name}</name>
-                    <type>{location_type}</type>
-                    <preset>{preset}</preset>
-                </location>
-            </locations>
-        '''
+        data = (
+            "<locations>"
+            f"<location id='{loc_id}''>"
+            f"<name>{location_name}</name>"
+            f"<type>{location_type}</type>"
+            f"<preset>{preset}</preset>"
+            "</location>"
+            "</locations>"
+        )
         uri = f"{LOCATIONS};id={loc_id}"
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def set_select(
         self, key: str, loc_id: str, option: str, state: str | None
@@ -240,13 +236,13 @@ async def set_dhw_mode(self, mode: str) -> None:
         if mode not in self._dhw_allowed_modes:
             raise PlugwiseError("Plugwise: invalid dhw mode.")
 
-        data = f"""
-            <domestic_hot_water_mode_control_functionality>
-                <mode>{mode}</mode>
-            </domestic_hot_water_mode_control_functionality>
-        """
+        data = (
+            "<domestic_hot_water_mode_control_functionality>"
+            f"<mode>{mode}</mode>"
+            "</domestic_hot_water_mode_control_functionality>"
+        )
         uri = f"{APPLIANCES};type=heater_central/domestic_hot_water_mode_control"
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def set_gateway_mode(self, mode: str) -> None:
         """Set the gateway mode."""
@@ -271,14 +267,14 @@ async def set_gateway_mode(self, mode: str) -> None:
             vacation_time = time_2 + "T23:00:00.000Z"
             valid = f"<valid_from>{vacation_time}</valid_from><valid_to>{end_time}</valid_to>"
 
-        data = f"""
-            <gateway_mode_control_functionality>
-                <mode>{mode}</mode>
-                {valid}
-            </gateway_mode_control_functionality>
-        """
+        data = (
+            "<gateway_mode_control_functionality>"
+            f"<mode>{mode}</mode>"
+            f"{valid}"
+            "</gateway_mode_control_functionality>"
+        )
         uri = f"{APPLIANCES};id={self._smile_props['gateway_id']}/gateway_mode_control"
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def set_regulation_mode(self, mode: str) -> None:
         """Set the heating regulation mode."""
@@ -289,14 +285,14 @@ async def set_regulation_mode(self, mode: str) -> None:
         if "bleeding" in mode:
             duration = "<duration>300</duration>"
 
-        data = f"""
-            <regulation_mode_control_functionality>
-                {duration}
-                <mode>{mode}</mode>
-            </regulation_mode_control_functionality>
-        """
+        data = (
+            "<regulation_mode_control_functionality>"
+            f"{duration}"
+            f"<mode>{mode}</mode>"
+            "</regulation_mode_control_functionality>"
+        )
         uri = f"{APPLIANCES};type=gateway/regulation_mode_control"
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def set_schedule_state(
         self,
@@ -344,17 +340,17 @@ async def set_schedule_state(
             template = f'<template id="{template_id}" />'
 
         contexts = self.determine_contexts(loc_id, name, new_state, schedule_rule_id)
-        data = f'''
-            <rules>
-                <rule id="{schedule_rule_id}">
-                    <name><![CDATA[{name}]]></name>
-                    {template}
-                    {contexts}
-                </rule>
-            </rules>
-        '''
+        data = (
+            "<rules>"
+            f"<rule id='{schedule_rule_id}'>"
+            f"<name><![CDATA[{name}]]></name>"
+            f"{template}"
+            f"{contexts}"
+            "</rule>"
+            "</rules>"
+        )
         uri = f"{RULES};id={schedule_rule_id}"
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
         self._schedule_old_states[loc_id][name] = new_state
 
     def determine_contexts(
@@ -412,11 +408,11 @@ async def set_switch_state(
                 switch_id = item.attrib["id"]
                 break
 
-        data = f"""
-            <{switch.func_type}>
-                <{switch.func}>{state}</{switch.func}>
-            </{switch.func_type}>
-        """
+        data = (
+            f"<{switch.func_type}>"
+            f"<{switch.func}>{state}</{switch.func}>"
+            f"</{switch.func_type}>"
+        )
         uri = f"{APPLIANCES};id={appl_id}/{switch.device};id={switch_id}"
         if model == "relay":
             locator = (
@@ -426,7 +422,7 @@ async def set_switch_state(
             if self._domain_objects.find(locator).text == "true":
                 raise PlugwiseError("Plugwise: the locked Relay was not switched.")
 
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def _set_groupswitch_member_state(
         self, members: list[str], state: str, switch: Munch
@@ -439,12 +435,12 @@ async def _set_groupswitch_member_state(
             locator = f'appliance[@id="{member}"]/{switch.actuator}/{switch.func_type}'
             switch_id = self._domain_objects.find(locator).attrib["id"]
             uri = f"{APPLIANCES};id={member}/{switch.device};id={switch_id}"
-            data = f"""
-                <{switch.func_type}>
-                    <{switch.func}>{state}</{switch.func}>
-                </{switch.func_type}>
-            """
-            await self.call_request(uri, method="put", data=data.strip())
+            data = (
+                f"<{switch.func_type}>"
+                f"<{switch.func}>{state}</{switch.func}>"
+                f"</{switch.func_type}>"
+            )
+            await self.call_request(uri, method="put", data=data)
 
     async def set_temperature(self, loc_id: str, items: dict[str, float]) -> None:
         """Set the given Temperature on the relevant Thermostat."""
@@ -479,13 +475,13 @@ async def set_temperature(self, loc_id: str, items: dict[str, float]) -> None:
             )  # pragma: no cover"
 
         temperature = str(setpoint)
-        data = f"""
-            <thermostat_functionality>
-                <setpoint>{temperature}</setpoint>
-            </thermostat_functionality>
-        """
+        data = (
+            "<thermostat_functionality>"
+            f"<setpoint>{temperature}</setpoint>"
+            "</thermostat_functionality>"
+        )
         uri = self._thermostat_uri(loc_id)
-        await self.call_request(uri, method="put", data=data.strip())
+        await self.call_request(uri, method="put", data=data)
 
     async def call_request(self, uri: str, **kwargs: Any) -> None:
         """ConnectionFailedError wrapper for calling request()."""