plugwise 0.37.1a2__py3-none-any.whl → 0.37.3__py3-none-any.whl

plugwise/legacy/smile.py

@@ -145,6 +145,34 @@ class SmileLegacyAPI(SmileComm, SmileLegacyData):
 ###  API Set and HA Service-related Functions                                                        ###
 ########################################################################################################
 
+    async def delete_notification(self) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def set_dhw_mode(self, mode: str) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def set_gateway_mode(self, mode: str) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def set_number_setpoint(self, key: str, temperature: float) -> None:
+        """Set-function placeholder for legacy devices."""
+
+    async def set_preset(self, _: str, preset: str) -> None:
+        """Set the given Preset on the relevant Thermostat - from DOMAIN_OBJECTS."""
+        if (presets := self._presets()) is None:
+            raise PlugwiseError("Plugwise: no presets available.")  # pragma: no cover
+        if preset not in list(presets):
+            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._request(RULES, method="put", data=data)
+
+    async def set_regulation_mode(self, mode: str) -> None:
+        """Set-function placeholder for legacy devices."""
+
     async def set_schedule_state(self, _: str, state: str, __: str | None) -> None:
         """Activate/deactivate the Schedule.
 
@@ -180,35 +208,6 @@ class SmileLegacyAPI(SmileComm, SmileLegacyData):
 
         await self._request(uri, method="put", data=data)
 
-    async def set_preset(self, _: str, preset: str) -> None:
-        """Set the given Preset on the relevant Thermostat - from DOMAIN_OBJECTS."""
-        if (presets := self._presets()) is None:
-            raise PlugwiseError("Plugwise: no presets available.")  # pragma: no cover
-        if preset not in list(presets):
-            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._request(RULES, method="put", data=data)
-
-    async def set_temperature(self, setpoint: str, _: dict[str, float]) -> None:
-        """Set the given Temperature on the relevant Thermostat."""
-        if setpoint is None:
-            raise PlugwiseError(
-                "Plugwise: failed setting temperature: no valid input provided"
-            )  # pragma: no cover"
-
-        temperature = str(setpoint)
-        uri = self._thermostat_uri()
-        data = (
-            "<thermostat_functionality><setpoint>"
-            f"{temperature}</setpoint></thermostat_functionality>"
-        )
-
-        await self._request(uri, method="put", data=data)
-
     async def set_switch_state(
         self, appl_id: str, members: list[str] | None, model: str, state: str
     ) -> None:
@@ -250,20 +249,25 @@ class SmileLegacyAPI(SmileComm, SmileLegacyData):
 
             await self._request(uri, method="put", data=data)
 
-    async def set_number_setpoint(self, key: str, temperature: float) -> None:
-        """Set-function placeholder for legacy devices."""
-
-    async def set_temperature_offset(self, dev_id: str, offset: float) -> None:
-        """Set-function placeholder for legacy devices."""
+    async def set_temperature(self, _: str, items: dict[str, float]) -> None:
+        """Set the given Temperature on the relevant Thermostat."""
+        setpoint: float | None = None
+        if "setpoint" in items:
+            setpoint = items["setpoint"]
 
-    async def set_gateway_mode(self, mode: str) -> None:
-        """Set-function placeholder for legacy devices."""
+        if setpoint is None:
+            raise PlugwiseError(
+                "Plugwise: failed setting temperature: no valid input provided"
+            )  # pragma: no cover"
 
-    async def set_regulation_mode(self, mode: str) -> None:
-        """Set-function placeholder for legacy devices."""
+        temperature = str(setpoint)
+        uri = self._thermostat_uri()
+        data = (
+            "<thermostat_functionality><setpoint>"
+            f"{temperature}</setpoint></thermostat_functionality>"
+        )
 
-    async def set_dhw_mode(self, mode: str) -> None:
-        """Set-function placeholder for legacy devices."""
+        await self._request(uri, method="put", data=data)
 
-    async def delete_notification(self) -> None:
+    async def set_temperature_offset(self, dev_id: str, offset: float) -> None:
         """Set-function placeholder for legacy devices."""

plugwise/smile.py

@@ -145,6 +145,93 @@ class SmileAPI(SmileComm, SmileData):
 ###  API Set and HA Service-related Functions                                                        ###
 ########################################################################################################
 
+    async def delete_notification(self) -> None:
+        """Delete the active Plugwise Notification."""
+        await self._request(NOTIFICATIONS, method="delete")
+
+    async def set_dhw_mode(self, mode: str) -> None:
+        """Set the domestic hot water heating regulation mode."""
+        if mode not in self._dhw_allowed_modes:
+            raise PlugwiseError("Plugwise: invalid dhw mode.")
+
+        uri = f"{APPLIANCES};type=heater_central/domestic_hot_water_mode_control"
+        data = f"<domestic_hot_water_mode_control_functionality><mode>{mode}</mode></domestic_hot_water_mode_control_functionality>"
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_gateway_mode(self, mode: str) -> None:
+        """Set the gateway mode."""
+        if mode not in self._gw_allowed_modes:
+            raise PlugwiseError("Plugwise: invalid gateway mode.")
+
+        end_time = "2037-04-21T08:00:53.000Z"
+        valid = ""
+        if mode == "away":
+            time_1 = self._domain_objects.find("./gateway/time").text
+            away_time = dt.datetime.fromisoformat(time_1).astimezone(dt.UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+            valid = (
+                f"<valid_from>{away_time}</valid_from><valid_to>{end_time}</valid_to>"
+            )
+        if mode == "vacation":
+            time_2 = str(dt.date.today() - dt.timedelta(1))
+            vacation_time = time_2 + "T23:00:00.000Z"
+            valid = f"<valid_from>{vacation_time}</valid_from><valid_to>{end_time}</valid_to>"
+
+        uri = f"{APPLIANCES};id={self.gateway_id}/gateway_mode_control"
+        data = f"<gateway_mode_control_functionality><mode>{mode}</mode>{valid}</gateway_mode_control_functionality>"
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_number_setpoint(self, key: str, temperature: float) -> None:
+        """Set the max. Boiler or DHW setpoint on the Central Heating boiler."""
+        temp = str(temperature)
+        thermostat_id: str | None = None
+        locator = f'appliance[@id="{self._heater_id}"]/actuator_functionalities/thermostat_functionality'
+        if th_func_list := self._domain_objects.findall(locator):
+            for th_func in th_func_list:
+                if th_func.find("type").text == key:
+                    thermostat_id = th_func.attrib["id"]
+
+        if thermostat_id is None:
+            raise PlugwiseError(f"Plugwise: cannot change setpoint, {key} not found.")
+
+        uri = f"{APPLIANCES};id={self._heater_id}/thermostat;id={thermostat_id}"
+        data = f"<thermostat_functionality><setpoint>{temp}</setpoint></thermostat_functionality>"
+        await self._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."""
+        if (presets := self._presets(loc_id)) is None:
+            raise PlugwiseError("Plugwise: no presets available.")  # pragma: no cover
+        if preset not in list(presets):
+            raise PlugwiseError("Plugwise: invalid preset.")
+
+        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
+
+        uri = f"{LOCATIONS};id={loc_id}"
+        data = (
+            "<locations><location"
+            f' id="{loc_id}"><name>{location_name}</name><type>{location_type}'
+            f"</type><preset>{preset}</preset></location></locations>"
+        )
+
+        await self._request(uri, method="put", data=data)
+
+    async def set_regulation_mode(self, mode: str) -> None:
+        """Set the heating regulation mode."""
+        if mode not in self._reg_allowed_modes:
+            raise PlugwiseError("Plugwise: invalid regulation mode.")
+
+        uri = f"{APPLIANCES};type=gateway/regulation_mode_control"
+        duration = ""
+        if "bleeding" in mode:
+            duration = "<duration>300</duration>"
+        data = f"<regulation_mode_control_functionality>{duration}<mode>{mode}</mode></regulation_mode_control_functionality>"
+
+        await self._request(uri, method="put", data=data)
+
     async def set_schedule_state(
         self,
         loc_id: str,
@@ -219,97 +306,6 @@ class SmileAPI(SmileComm, SmileData):
 
         return etree.tostring(contexts, encoding="unicode").rstrip()
 
-    async def set_preset(self, loc_id: str, preset: str) -> None:
-        """Set the given Preset on the relevant Thermostat - from LOCATIONS."""
-        if (presets := self._presets(loc_id)) is None:
-            raise PlugwiseError("Plugwise: no presets available.")  # pragma: no cover
-        if preset not in list(presets):
-            raise PlugwiseError("Plugwise: invalid preset.")
-
-        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
-
-        uri = f"{LOCATIONS};id={loc_id}"
-        data = (
-            "<locations><location"
-            f' id="{loc_id}"><name>{location_name}</name><type>{location_type}'
-            f"</type><preset>{preset}</preset></location></locations>"
-        )
-
-        await self._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."""
-        setpoint: float | None = None
-
-        if "setpoint" in items:
-            setpoint = items["setpoint"]
-
-        if self.smile(ANNA) and self._cooling_present:
-            if "setpoint_high" not in items:
-                raise PlugwiseError(
-                    "Plugwise: failed setting temperature: no valid input provided"
-                )
-            tmp_setpoint_high = items["setpoint_high"]
-            tmp_setpoint_low = items["setpoint_low"]
-            if self._cooling_enabled:  # in cooling mode
-                setpoint = tmp_setpoint_high
-                if tmp_setpoint_low != MIN_SETPOINT:
-                    raise PlugwiseError(
-                        "Plugwise: heating setpoint cannot be changed when in cooling mode"
-                    )
-            else:  # in heating mode
-                setpoint = tmp_setpoint_low
-                if tmp_setpoint_high != MAX_SETPOINT:
-                    raise PlugwiseError(
-                        "Plugwise: cooling setpoint cannot be changed when in heating mode"
-                    )
-
-        if setpoint is None:
-            raise PlugwiseError(
-                    "Plugwise: failed setting temperature: no valid input provided"
-                )  # pragma: no cover"
-
-        temperature = str(setpoint)
-        uri = self._thermostat_uri(loc_id)
-        data = (
-            "<thermostat_functionality><setpoint>"
-            f"{temperature}</setpoint></thermostat_functionality>"
-        )
-
-        await self._request(uri, method="put", data=data)
-
-    async def set_number_setpoint(self, key: str, temperature: float) -> None:
-        """Set the max. Boiler or DHW setpoint on the Central Heating boiler."""
-        temp = str(temperature)
-        thermostat_id: str | None = None
-        locator = f'appliance[@id="{self._heater_id}"]/actuator_functionalities/thermostat_functionality'
-        if th_func_list := self._domain_objects.findall(locator):
-            for th_func in th_func_list:
-                if th_func.find("type").text == key:
-                    thermostat_id = th_func.attrib["id"]
-
-        if thermostat_id is None:
-            raise PlugwiseError(f"Plugwise: cannot change setpoint, {key} not found.")
-
-        uri = f"{APPLIANCES};id={self._heater_id}/thermostat;id={thermostat_id}"
-        data = f"<thermostat_functionality><setpoint>{temp}</setpoint></thermostat_functionality>"
-        await self._request(uri, method="put", data=data)
-
-    async def set_temperature_offset(self, dev_id: str, offset: float) -> None:
-        """Set the Temperature offset for thermostats that support this feature."""
-        if dev_id not in self.therms_with_offset_func:
-            raise PlugwiseError(
-                "Plugwise: this device does not have temperature-offset capability."
-            )
-
-        value = str(offset)
-        uri = f"{APPLIANCES};id={dev_id}/offset;type=temperature_offset"
-        data = f"<offset_functionality><offset>{value}</offset></offset_functionality>"
-
-        await self._request(uri, method="put", data=data)
-
     async def set_switch_state(
         self, appl_id: str, members: list[str] | None, model: str, state: str
     ) -> None:
@@ -374,52 +370,56 @@ class SmileAPI(SmileComm, SmileData):
 
             await self._request(uri, method="put", data=data)
 
-    async def set_gateway_mode(self, mode: str) -> None:
-        """Set the gateway mode."""
-        if mode not in self._gw_allowed_modes:
-            raise PlugwiseError("Plugwise: invalid gateway mode.")
-
-        end_time = "2037-04-21T08:00:53.000Z"
-        valid = ""
-        if mode == "away":
-            time_1 = self._domain_objects.find("./gateway/time").text
-            away_time = dt.datetime.fromisoformat(time_1).astimezone(dt.UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")
-            valid = (
-                f"<valid_from>{away_time}</valid_from><valid_to>{end_time}</valid_to>"
-            )
-        if mode == "vacation":
-            time_2 = str(dt.date.today() - dt.timedelta(1))
-            vacation_time = time_2 + "T23:00:00.000Z"
-            valid = f"<valid_from>{vacation_time}</valid_from><valid_to>{end_time}</valid_to>"
+    async def set_temperature(self, loc_id: str, items: dict[str, float]) -> None:
+        """Set the given Temperature on the relevant Thermostat."""
+        setpoint: float | None = None
 
-        uri = f"{APPLIANCES};id={self.gateway_id}/gateway_mode_control"
-        data = f"<gateway_mode_control_functionality><mode>{mode}</mode>{valid}</gateway_mode_control_functionality>"
+        if "setpoint" in items:
+            setpoint = items["setpoint"]
 
-        await self._request(uri, method="put", data=data)
+        if self.smile(ANNA) and self._cooling_present:
+            if "setpoint_high" not in items:
+                raise PlugwiseError(
+                    "Plugwise: failed setting temperature: no valid input provided"
+                )
+            tmp_setpoint_high = items["setpoint_high"]
+            tmp_setpoint_low = items["setpoint_low"]
+            if self._cooling_enabled:  # in cooling mode
+                setpoint = tmp_setpoint_high
+                if tmp_setpoint_low != MIN_SETPOINT:
+                    raise PlugwiseError(
+                        "Plugwise: heating setpoint cannot be changed when in cooling mode"
+                    )
+            else:  # in heating mode
+                setpoint = tmp_setpoint_low
+                if tmp_setpoint_high != MAX_SETPOINT:
+                    raise PlugwiseError(
+                        "Plugwise: cooling setpoint cannot be changed when in heating mode"
+                    )
 
-    async def set_regulation_mode(self, mode: str) -> None:
-        """Set the heating regulation mode."""
-        if mode not in self._reg_allowed_modes:
-            raise PlugwiseError("Plugwise: invalid regulation mode.")
+        if setpoint is None:
+            raise PlugwiseError(
+                    "Plugwise: failed setting temperature: no valid input provided"
+                )  # pragma: no cover"
 
-        uri = f"{APPLIANCES};type=gateway/regulation_mode_control"
-        duration = ""
-        if "bleeding" in mode:
-            duration = "<duration>300</duration>"
-        data = f"<regulation_mode_control_functionality>{duration}<mode>{mode}</mode></regulation_mode_control_functionality>"
+        temperature = str(setpoint)
+        uri = self._thermostat_uri(loc_id)
+        data = (
+            "<thermostat_functionality><setpoint>"
+            f"{temperature}</setpoint></thermostat_functionality>"
+        )
 
         await self._request(uri, method="put", data=data)
 
-    async def set_dhw_mode(self, mode: str) -> None:
-        """Set the domestic hot water heating regulation mode."""
-        if mode not in self._dhw_allowed_modes:
-            raise PlugwiseError("Plugwise: invalid dhw mode.")
+    async def set_temperature_offset(self, dev_id: str, offset: float) -> None:
+        """Set the Temperature offset for thermostats that support this feature."""
+        if dev_id not in self.therms_with_offset_func:
+            raise PlugwiseError(
+                "Plugwise: this device does not have temperature-offset capability."
+            )
 
-        uri = f"{APPLIANCES};type=heater_central/domestic_hot_water_mode_control"
-        data = f"<domestic_hot_water_mode_control_functionality><mode>{mode}</mode></domestic_hot_water_mode_control_functionality>"
+        value = str(offset)
+        uri = f"{APPLIANCES};id={dev_id}/offset;type=temperature_offset"
+        data = f"<offset_functionality><offset>{value}</offset></offset_functionality>"
 
         await self._request(uri, method="put", data=data)
-
-    async def delete_notification(self) -> None:
-        """Delete the active Plugwise Notification."""
-        await self._request(NOTIFICATIONS, method="delete")

plugwise/util.py

@@ -1,6 +1,7 @@
 """Plugwise protocol helpers."""
 from __future__ import annotations
 
+import datetime as dt
 import re
 
 from plugwise.constants import (
@@ -8,6 +9,7 @@ from plugwise.constants import (
     ELECTRIC_POTENTIAL_VOLT,
     ENERGY_KILO_WATT_HOUR,
     HW_MODELS,
+    OBSOLETE_MEASUREMENTS,
     PERCENTAGE,
     POWER_WATT,
     SPECIAL_FORMAT,
@@ -17,6 +19,50 @@ from plugwise.constants import (
 )
 
 from defusedxml import ElementTree as etree
+from munch import Munch
+
+
+def check_alternative_location(loc: Munch, legacy: bool) -> Munch:
+    """Try."""
+    if in_alternative_location(loc, legacy):
+        # Avoid double processing by skipping one peak-list option
+        if loc.peak_select == "nl_offpeak":
+            loc.found = False
+            return loc
+
+        loc.locator = (
+            f'./{loc.log_type}[type="{loc.measurement}"]/period/measurement'
+        )
+        if legacy:
+            loc.locator = (
+                f"./{loc.meas_list[0]}_{loc.log_type}/"
+                f'measurement[@directionality="{loc.meas_list[1]}"]'
+            )
+
+        if loc.logs.find(loc.locator) is None:
+            loc.found = False
+            return loc
+
+        return loc
+
+    loc.found = False
+    return loc
+
+
+def in_alternative_location(loc: Munch, legacy: bool) -> bool:
+    """Look for P1 gas_consumed or phase data (without tariff).
+
+    For legacy look for P1 legacy electricity_point_meter or gas_*_meter data.
+    """
+    present = "log" in loc.log_type and (
+        "gas" in loc.measurement or "phase" in loc.measurement
+        )
+    if legacy:
+        present = "meter" in loc.log_type and (
+            "point" in loc.log_type or "gas" in loc.measurement
+            )
+
+    return present
 
 
 def check_heater_central(xml: etree) -> str:
@@ -128,6 +174,22 @@ def return_valid(value: etree | None, default: etree) -> etree:
     return value if value is not None else default
 
 
+def skip_obsolete_measurements(xml: etree, measurement: str) -> bool:
+    """Skipping known obsolete measurements."""
+    locator = f".//logs/point_log[type='{measurement}']/updated_date"
+    if (
+        measurement in OBSOLETE_MEASUREMENTS
+        and (updated_date_key := xml.find(locator))
+        is not None
+    ):
+        updated_date = updated_date_key.text.split("T")[0]
+        date_1 = dt.datetime.strptime(updated_date, "%Y-%m-%d")
+        date_2 = dt.datetime.now()
+        return int((date_2 - date_1).days) > 7
+
+    return False
+
+
 # NOTE: this function version_to_model is shared between Smile and USB
 def version_to_model(version: str | None) -> str | None:
     """Translate hardware_version to device type."""

{plugwise-0.37.1a2.dist-info → plugwise-0.37.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: plugwise
-Version: 0.37.1a2
+Version: 0.37.3
 Summary: Plugwise Smile (Adam/Anna/P1) and Stretch module for Python 3.
 Home-page: https://github.com/plugwise/python-plugwise
 Author: Plugwise device owners
@@ -35,18 +35,14 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Home Automation
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
-Requires-Dist: async-timeout
-Requires-Dist: crcmod
 Requires-Dist: defusedxml
 Requires-Dist: munch
-Requires-Dist: pyserial
 Requires-Dist: python-dateutil
 
 # Plugwise python module

plugwise-0.37.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+plugwise/__init__.py,sha256=A0XCK9xmhzLGSsy0bAGr2tnKfGDUlJ7WzQfeIqCCd8A,14004
+plugwise/common.py,sha256=P4sUYzgVcFsIR2DmQxeVeOiZvFZWpZXgwHA3XRc1Sx0,12538
+plugwise/constants.py,sha256=adi2UFHJUcPRWNz1bn155NC9DLzhYbeNriMKTpSyWAg,16574
+plugwise/data.py,sha256=OTkPJ80b1L1h_TeddfvmUPX1-jBacTjbHKD0XgUIfeg,8965
+plugwise/exceptions.py,sha256=rymGtWnXosdFkzSehc_41HVl2jXJEg_9Hq9APDEUwrk,1223
+plugwise/helper.py,sha256=bNT_Tdc0LAxmVZEikMgKm461jeGP-WY-cI1r3JGgIcI,44037
+plugwise/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugwise/smile.py,sha256=_1VFG81pfuy673M8kGQVfpSX3Kdin2Xl7-KsUXNpGlY,16985
+plugwise/util.py,sha256=w24CiW-xSV3ARZAeNYZ9T5C4kJpYGCcBoIlX2BhNOYg,6618
+plugwise/legacy/data.py,sha256=y7gBG9Sg40lltB3B5CpWPtAXggMbcx2IMay-mwvOB1M,2986
+plugwise/legacy/helper.py,sha256=tSrqA2UeMO7HSYudQHAxBThBTevAOKIxHqN6NCN-r5k,18947
+plugwise/legacy/smile.py,sha256=JlJGg2TNl1uBeW-vLzsHzrpeizKpZqN9coiDYcedHuc,10347
+plugwise-0.37.3.dist-info/LICENSE,sha256=mL22BjmXtg_wnoDnnaqps5_Bg_VGj_yHueX5lsKwbCc,1144
+plugwise-0.37.3.dist-info/METADATA,sha256=Tgjez9bNSQ3C-UrLQR8cL0aZwzojQX-PYmSCaZht6N8,8939
+plugwise-0.37.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+plugwise-0.37.3.dist-info/top_level.txt,sha256=MYOmktMFf8ZmX6_OE1y9MoCZFfY-L8DA0F2tA2IvE4s,9
+plugwise-0.37.3.dist-info/RECORD,,

{plugwise-0.37.1a2.dist-info → plugwise-0.37.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

plugwise-0.37.1a2.dist-info/RECORD

@@ -1,17 +0,0 @@
-plugwise/__init__.py,sha256=A0XCK9xmhzLGSsy0bAGr2tnKfGDUlJ7WzQfeIqCCd8A,14004
-plugwise/common.py,sha256=Apn_pgiOGypwwc5aCwIXFeOceLel0CysHHxj_GVDej8,5914
-plugwise/constants.py,sha256=_IO-MQQu_gFZ71VTNlmNY5Lqr6u0t5rWaQTQJqe_xRc,16467
-plugwise/data.py,sha256=wed7BfOI7QCIFlen6zv5jx4zG3SRM8YDoeGP7XfN8nA,9495
-plugwise/exceptions.py,sha256=rymGtWnXosdFkzSehc_41HVl2jXJEg_9Hq9APDEUwrk,1223
-plugwise/helper.py,sha256=_hpaQrrS2npI2f0UwwthU-pq4kzspnkurwIH4ewKJ7Y,51658
-plugwise/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-plugwise/smile.py,sha256=_86nL1mVaN0GJ7XwDzlVFjkDorsdfIFLFJ2vs2woI_Y,16985
-plugwise/util.py,sha256=PTAwKODUcTL7C87CF-ul_6nC2TcQrHVXEZb5qY5sy0I,4756
-plugwise/legacy/data.py,sha256=bomP7t2NwNIhSRGBZRXLuAHnXUiIqtpnHWseovXkRK0,3614
-plugwise/legacy/helper.py,sha256=RkrgchFtju32GeJ8F0eeOEVfJWP-etWFkJyo6VhvnxQ,26105
-plugwise/legacy/smile.py,sha256=49vJtlToio9StrkpNeztOAJ1mRtqrDX463APxFTtGd4,10238
-plugwise-0.37.1a2.dist-info/LICENSE,sha256=mL22BjmXtg_wnoDnnaqps5_Bg_VGj_yHueX5lsKwbCc,1144
-plugwise-0.37.1a2.dist-info/METADATA,sha256=tRECCBQ9XJak1ZjLkAnoqxFmM5wjFd6ncDz3Spw3jQo,9067
-plugwise-0.37.1a2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-plugwise-0.37.1a2.dist-info/top_level.txt,sha256=MYOmktMFf8ZmX6_OE1y9MoCZFfY-L8DA0F2tA2IvE4s,9
-plugwise-0.37.1a2.dist-info/RECORD,,