plugwise 1.6.3__py3-none-any.whl → 1.7.0__py3-none-any.whl

plugwise/smile.py

@@ -2,6 +2,7 @@
 
 Plugwise backend module for Home Assistant Core.
 """
+
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
@@ -12,8 +13,6 @@ from plugwise.constants import (
     ADAM,
     ANNA,
     APPLIANCES,
-    DEFAULT_PORT,
-    DEFAULT_USERNAME,
     DOMAIN_OBJECTS,
     GATEWAY_REBOOT,
     LOCATIONS,
@@ -22,15 +21,13 @@ from plugwise.constants import (
     NOTIFICATIONS,
     OFF,
     RULES,
-    GatewayData,
     GwEntityData,
-    PlugwiseData,
+    SmileProps,
     ThermoLoc,
 )
 from plugwise.data import SmileData
 from plugwise.exceptions import ConnectionFailedError, DataMissingError, PlugwiseError
 
-import aiohttp
 from defusedxml import ElementTree as etree
 
 # Dict as class
@@ -45,10 +42,6 @@ class SmileAPI(SmileData):
 
     def __init__(
         self,
-        host: str,
-        password: str,
-        request: Callable[..., Awaitable[Any]],
-        websession: aiohttp.ClientSession,
         _cooling_present: bool,
         _elga: bool,
         _is_thermostat: bool,
@@ -56,9 +49,9 @@ class SmileAPI(SmileData):
         _loc_data: dict[str, ThermoLoc],
         _on_off_device: bool,
         _opentherm_device: bool,
+        _request: Callable[..., Awaitable[Any]],
         _schedule_old_states: dict[str, dict[str, str]],
-        gateway_id: str,
-        smile_fw_version: Version | None,
+        _smile_props: SmileProps,
         smile_hostname: str | None,
         smile_hw_version: str | None,
         smile_mac_address: str | None,
@@ -67,23 +60,18 @@ class SmileAPI(SmileData):
         smile_name: str,
         smile_type: str,
         smile_version: Version | None,
-        port: int = DEFAULT_PORT,
-        username: str = DEFAULT_USERNAME,
     ) -> None:
         """Set the constructor for this class."""
-        self._cooling_enabled = False
         self._cooling_present = _cooling_present
         self._elga = _elga
-        self._heater_id: str
         self._is_thermostat = _is_thermostat
         self._last_active = _last_active
         self._loc_data = _loc_data
         self._on_off_device = _on_off_device
         self._opentherm_device = _opentherm_device
+        self._request = _request
         self._schedule_old_states = _schedule_old_states
-        self.gateway_id = gateway_id
-        self.request = request
-        self.smile_fw_version = smile_fw_version
+        self._smile_props = _smile_props
         self.smile_hostname = smile_hostname
         self.smile_hw_version = smile_hw_version
         self.smile_mac_address = smile_mac_address
@@ -92,65 +80,66 @@ class SmileAPI(SmileData):
         self.smile_name = smile_name
         self.smile_type = smile_type
         self.smile_version = smile_version
+        self.therms_with_offset_func: list[str] = []
         SmileData.__init__(self)
 
-
     async def full_xml_update(self) -> None:
-        """Perform a first fetch of all XML data, needed for initialization."""
-        self._domain_objects = await self.request(DOMAIN_OBJECTS)
+        """Perform a first fetch of the Plugwise server XML data."""
+        self._domain_objects = await self._request(DOMAIN_OBJECTS)
         self._get_plugwise_notifications()
 
     def get_all_gateway_entities(self) -> None:
-        """Collect the gateway entities from the received raw XML-data.
+        """Collect the Plugwise gateway entities and their data and states from the received raw XML-data.
 
-        Run this functions once to gather the initial configuration,
-        then regularly run async_update() to refresh the entity data.
+        First, collect all the connected entities and their initial data.
+        If a thermostat-gateway, collect a list of thermostats with offset-capability.
+        Collect and add switching- and/or pump-group entities.
+        Finally, collect the data and states for each entity.
         """
-        # Gather all the entities and their initial data
         self._all_appliances()
         if self._is_thermostat:
-            if self.smile(ADAM):
-                self._scan_thermostats()
-            # Collect a list of thermostats with offset-capability
             self.therms_with_offset_func = (
                 self._get_appliances_with_offset_functionality()
             )
+            if self.smile(ADAM):
+                self._scan_thermostats()
 
-        # Collect and add switching- and/or pump-group devices
         if group_data := self._get_group_switches():
             self.gw_entities.update(group_data)
 
-        # Collect the remaining data for all entities
         self._all_entity_data()
 
-    async def async_update(self) -> PlugwiseData:
-        """Perform an incremental update for updating the various device states."""
-        self.gw_data: GatewayData = {}
-        self.gw_entities: dict[str, GwEntityData] = {}
-        self._zones: dict[str, GwEntityData] = {}
+    async def async_update(self) -> dict[str, GwEntityData]:
+        """Perform an full update: re-collect all gateway entities and their data and states.
+
+        Any change in the connected entities will be detected immediately.
+        """
+        self._zones = {}
+        self.gw_entities = {}
         try:
             await self.full_xml_update()
             self.get_all_gateway_entities()
-            # Set self._cooling_enabled -required for set_temperature,
-            #also, check for a failed data-retrieval
-            if "heater_id" in self.gw_data:
-                heat_cooler = self.gw_entities[self.gw_data["heater_id"]]
+            # Set self._cooling_enabled - required for set_temperature(),
+            # also, check for a failed data-retrieval
+            if "heater_id" in self._smile_props:
+                heat_cooler = self.gw_entities[self._smile_props["heater_id"]]
                 if (
                     "binary_sensors" in heat_cooler
                     and "cooling_enabled" in heat_cooler["binary_sensors"]
                 ):
-                    self._cooling_enabled = heat_cooler["binary_sensors"]["cooling_enabled"]
+                    self._cooling_enabled = heat_cooler["binary_sensors"][
+                        "cooling_enabled"
+                    ]
+            else:  # cover failed data-retrieval for P1
+                _ = self.gw_entities[self._smile_props["gateway_id"]]["location"]
         except KeyError as err:
-            raise DataMissingError("No Plugwise data received") from err
+            raise DataMissingError("No Plugwise actual data received") from err
 
-        return PlugwiseData(
-            devices=self.gw_entities,
-            gateway=self.gw_data,
-        )
+        return self.gw_entities
 
-########################################################################################################
-###  API Set and HA Service-related Functions                                                        ###
-########################################################################################################
+    ########################################################################################################
+    ###  API Set and HA Service-related Functions                                                        ###
+    ########################################################################################################
 
     async def delete_notification(self) -> None:
         """Delete the active Plugwise Notification."""
@@ -222,7 +211,9 @@ class SmileAPI(SmileData):
 
         await self.call_request(uri, method="put", data=data)
 
-    async def set_select(self, key: str, loc_id: str, option: str, state: str | None) -> None:
+    async def set_select(
+        self, key: str, loc_id: str, option: str, state: str | None
+    ) -> None:
         """Set a dhw/gateway/regulation mode or the thermostat schedule option."""
         match key:
             case "select_dhw_mode":
@@ -254,7 +245,12 @@ class SmileAPI(SmileData):
         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")
+            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>"
             )
@@ -263,7 +259,7 @@ class SmileAPI(SmileData):
             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"
+        uri = f"{APPLIANCES};id={self._smile_props['gateway_id']}/gateway_mode_control"
         data = f"<gateway_mode_control_functionality><mode>{mode}</mode>{valid}</gateway_mode_control_functionality>"
 
         await self.call_request(uri, method="put", data=data)
@@ -448,8 +444,8 @@ class SmileAPI(SmileData):
 
         if setpoint is None:
             raise PlugwiseError(
-                    "Plugwise: failed setting temperature: no valid input provided"
-                )  # pragma: no cover"
+                "Plugwise: failed setting temperature: no valid input provided"
+            )  # pragma: no cover"
 
         temperature = str(setpoint)
         uri = self._thermostat_uri(loc_id)
@@ -465,6 +461,6 @@ class SmileAPI(SmileData):
         method: str = kwargs["method"]
         data: str | None = kwargs.get("data")
         try:
-            await self.request(uri, method=method, data=data)
+            await self._request(uri, method=method, data=data)
         except ConnectionFailedError as exc:
             raise ConnectionFailedError from exc

plugwise/smilecomm.py

@@ -0,0 +1,148 @@
+"""Use of this source code is governed by the MIT license found in the LICENSE file.
+
+Plugwise Smile communication protocol helpers.
+"""
+
+from __future__ import annotations
+
+from plugwise.constants import LOGGER
+from plugwise.exceptions import (
+    ConnectionFailedError,
+    InvalidAuthentication,
+    InvalidXMLError,
+    ResponseError,
+)
+from plugwise.util import escape_illegal_xml_characters
+
+# This way of importing aiohttp is because of patch/mocking in testing (aiohttp timeouts)
+from aiohttp import BasicAuth, ClientError, ClientResponse, ClientSession, ClientTimeout
+from defusedxml import ElementTree as etree
+
+
+class SmileComm:
+    """The SmileComm class."""
+
+    def __init__(
+        self,
+        host: str,
+        password: str,
+        port: int,
+        timeout: int,
+        username: str,
+        websession: ClientSession | None,
+    ) -> None:
+        """Set the constructor for this class."""
+        if not websession:
+            aio_timeout = ClientTimeout(total=timeout)
+            self._websession = ClientSession(timeout=aio_timeout)
+        else:
+            self._websession = websession
+
+        # Quickfix IPv6 formatting, not covering
+        if host.count(":") > 2:  # pragma: no cover
+            host = f"[{host}]"
+
+        self._auth = BasicAuth(username, password=password)
+        self._endpoint = f"http://{host}:{str(port)}"  # Sensitive
+
+    async def _request(
+        self,
+        command: str,
+        retry: int = 3,
+        method: str = "get",
+        data: str | None = None,
+    ) -> etree:
+        """Get/put/delete data from a give URL."""
+        resp: ClientResponse
+        url = f"{self._endpoint}{command}"
+        try:
+            match method:
+                case "delete":
+                    resp = await self._websession.delete(url, auth=self._auth)
+                case "get":
+                    # Work-around for Stretchv2, should not hurt the other smiles
+                    headers = {"Accept-Encoding": "gzip"}
+                    resp = await self._websession.get(
+                        url, headers=headers, auth=self._auth
+                    )
+                case "post":
+                    headers = {"Content-type": "text/xml"}
+                    resp = await self._websession.post(
+                        url,
+                        headers=headers,
+                        data=data,
+                        auth=self._auth,
+                    )
+                case "put":
+                    headers = {"Content-type": "text/xml"}
+                    resp = await self._websession.put(
+                        url,
+                        headers=headers,
+                        data=data,
+                        auth=self._auth,
+                    )
+        except (
+            ClientError
+        ) as exc:  # ClientError is an ancestor class of ServerTimeoutError
+            if retry < 1:
+                LOGGER.warning(
+                    "Failed sending %s %s to Plugwise Smile, error: %s",
+                    method,
+                    command,
+                    exc,
+                )
+                raise ConnectionFailedError from exc
+            return await self._request(command, retry - 1)
+
+        if resp.status == 504:
+            if retry < 1:
+                LOGGER.warning(
+                    "Failed sending %s %s to Plugwise Smile, error: %s",
+                    method,
+                    command,
+                    "504 Gateway Timeout",
+                )
+                raise ConnectionFailedError
+            return await self._request(command, retry - 1)
+
+        return await self._request_validate(resp, method)
+
+    async def _request_validate(self, resp: ClientResponse, method: str) -> etree:
+        """Helper-function for _request(): validate the returned data."""
+        match resp.status:
+            case 200:
+                # Cornercases for server not responding with 202
+                if method in ("post", "put"):
+                    return
+            case 202:
+                # Command accepted gives empty body with status 202
+                return
+            case 401:
+                msg = (
+                    "Invalid Plugwise login, please retry with the correct credentials."
+                )
+                LOGGER.error("%s", msg)
+                raise InvalidAuthentication
+            case 405:
+                msg = "405 Method not allowed."
+                LOGGER.error("%s", msg)
+                raise ConnectionFailedError
+
+        if not (result := await resp.text()) or (
+            "<error>" in result and "Not started" not in result
+        ):
+            LOGGER.warning("Smile response empty or error in %s", result)
+            raise ResponseError
+
+        try:
+            # Encode to ensure utf8 parsing
+            xml = etree.XML(escape_illegal_xml_characters(result).encode())
+        except etree.ParseError as exc:
+            LOGGER.warning("Smile returns invalid XML for %s", self._endpoint)
+            raise InvalidXMLError from exc
+
+        return xml
+
+    async def close_connection(self) -> None:
+        """Close the Plugwise connection."""
+        await self._websession.close()

plugwise/util.py

@@ -1,4 +1,5 @@
 """Plugwise protocol helpers."""
+
 from __future__ import annotations
 
 import datetime as dt
@@ -19,7 +20,6 @@ from plugwise.constants import (
     SPECIAL_FORMAT,
     SPECIALS,
     SWITCHES,
-    TEMP_CELSIUS,
     UOM,
     BinarySensorType,
     GwEntityData,
@@ -41,9 +41,7 @@ def check_alternative_location(loc: Munch, legacy: bool) -> Munch:
             loc.found = False
             return loc
 
-        loc.locator = (
-            f'./{loc.log_type}[type="{loc.measurement}"]/period/measurement'
-        )
+        loc.locator = f'./{loc.log_type}[type="{loc.measurement}"]/period/measurement'
         if legacy:
             loc.locator = (
                 f"./{loc.meas_list[0]}_{loc.log_type}/"
@@ -67,11 +65,11 @@ def in_alternative_location(loc: Munch, legacy: bool) -> bool:
     """
     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
 
@@ -118,6 +116,30 @@ def check_model(name: str | None, vendor_name: str | None) -> str | None:
     return None
 
 
+def collect_power_values(
+    data: GwEntityData, loc: Munch, tariff: str, legacy: bool = False
+) -> None:
+    """Something."""
+    for loc.peak_select in ("nl_peak", "nl_offpeak"):
+        loc.locator = (
+            f'./{loc.log_type}[type="{loc.measurement}"]/period/'
+            f'measurement[@{tariff}="{loc.peak_select}"]'
+        )
+        if legacy:
+            loc.locator = (
+                f"./{loc.meas_list[0]}_{loc.log_type}/measurement"
+                f'[@directionality="{loc.meas_list[1]}"][@{tariff}="{loc.peak_select}"]'
+            )
+
+        loc = power_data_peak_value(loc, legacy)
+        if not loc.found:
+            continue
+
+        data = power_data_energy_diff(loc.measurement, loc.net_string, loc.f_val, data)
+        key = cast(SensorType, loc.key_string)
+        data["sensors"][key] = loc.f_val
+
+
 def common_match_cases(
     measurement: str,
     attrs: DATA | UOM,
@@ -147,6 +169,22 @@ def common_match_cases(
         data["binary_sensors"]["low_battery"] = False
 
 
+def count_data_items(count: int, data: GwEntityData) -> int:
+    """When present, count the binary_sensors, sensors and switches dict-items, don't count the dicts.
+
+    Also, count the remaining single data items, the amount of dicts present have already been pre-subtracted in the previous step.
+    """
+    if "binary_sensors" in data:
+        count += len(data["binary_sensors"]) - 1
+    if "sensors" in data:
+        count += len(data["sensors"]) - 1
+    if "switches" in data:
+        count += len(data["switches"]) - 1
+
+    count += len(data)
+    return count
+
+
 def escape_illegal_xml_characters(xmldata: str) -> str:
     """Replace illegal &-characters."""
     return re.sub(r"&([^a-zA-Z#])", r"&\1", xmldata)
@@ -155,26 +193,22 @@ def escape_illegal_xml_characters(xmldata: str) -> str:
 def format_measure(measure: str, unit: str) -> float | int:
     """Format measure to correct type."""
     result: float | int = 0
-    try:
-        result = int(measure)
-        if unit == TEMP_CELSIUS:
-            result = float(measure)
-    except ValueError:
-        float_measure = float(measure)
-        if unit == PERCENTAGE and 0 < float_measure <= 1:
-            return int(float_measure * 100)
-
-        if unit == ENERGY_KILO_WATT_HOUR:
-            float_measure = float_measure / 1000
-
-        if unit in SPECIAL_FORMAT:
-            result = float(f"{round(float_measure, 3):.3f}")
-        elif unit == ELECTRIC_POTENTIAL_VOLT:
-            result = float(f"{round(float_measure, 1):.1f}")
-        elif abs(float_measure) < 10:
-            result = float(f"{round(float_measure, 2):.2f}")
-        elif abs(float_measure) >= 10:
-            result = float(f"{round(float_measure, 1):.1f}")
+
+    float_measure = float(measure)
+    if unit == PERCENTAGE and 0 < float_measure <= 1:
+        return int(float_measure * 100)
+
+    if unit == ENERGY_KILO_WATT_HOUR:
+        float_measure = float_measure / 1000
+
+    if unit in SPECIAL_FORMAT:
+        result = float(f"{round(float_measure, 3):.3f}")
+    elif unit == ELECTRIC_POTENTIAL_VOLT:
+        result = float(f"{round(float_measure, 1):.1f}")
+    elif abs(float_measure) < 10:
+        result = float(f"{round(float_measure, 2):.2f}")
+    elif abs(float_measure) >= 10:
+        result = float(f"{round(float_measure, 1):.1f}")
 
     return result
 
@@ -189,6 +223,37 @@ def get_vendor_name(module: etree, model_data: ModuleData) -> ModuleData:
     return model_data
 
 
+def power_data_energy_diff(
+    measurement: str,
+    net_string: SensorType,
+    f_val: float | int,
+    data: GwEntityData,
+) -> GwEntityData:
+    """Calculate differential energy."""
+    if (
+        "electricity" in measurement
+        and "phase" not in measurement
+        and "interval" not in net_string
+    ):
+        diff = 1
+        if "produced" in measurement:
+            diff = -1
+        if net_string not in data["sensors"]:
+            tmp_val: float | int = 0
+        else:
+            tmp_val = data["sensors"][net_string]
+
+        if isinstance(f_val, int):
+            tmp_val += f_val * diff
+        else:
+            tmp_val += float(f_val * diff)
+            tmp_val = float(f"{round(tmp_val, 3):.3f}")
+
+        data["sensors"][net_string] = tmp_val
+
+    return data
+
+
 def power_data_local_format(
     attrs: dict[str, str], key_string: str, val: str
 ) -> float | int:
@@ -202,6 +267,31 @@ def power_data_local_format(
     return format_measure(val, attrs_uom)
 
 
+def power_data_peak_value(loc: Munch, legacy: bool) -> Munch:
+    """Helper-function for _power_data_from_location() and _power_data_from_modules()."""
+    loc.found = True
+    if loc.logs.find(loc.locator) is None:
+        loc = check_alternative_location(loc, legacy)
+        if not loc.found:
+            return loc
+
+    if (peak := loc.peak_select.split("_")[1]) == "offpeak":
+        peak = "off_peak"
+    log_found = loc.log_type.split("_")[0]
+    loc.key_string = f"{loc.measurement}_{peak}_{log_found}"
+    if "gas" in loc.measurement or loc.log_type == "point_meter":
+        loc.key_string = f"{loc.measurement}_{log_found}"
+    # Only for P1 Actual -------------------#
+    if "phase" in loc.measurement:
+        loc.key_string = f"{loc.measurement}"
+    # --------------------------------------#
+    loc.net_string = f"net_electricity_{log_found}"
+    val = loc.logs.find(loc.locator).text
+    loc.f_val = power_data_local_format(loc.attrs, loc.key_string, val)
+
+    return loc
+
+
 def remove_empty_platform_dicts(data: GwEntityData) -> None:
     """Helper-function for removing any empty platform dicts."""
     if not data["binary_sensors"]:
@@ -222,8 +312,7 @@ def skip_obsolete_measurements(xml: etree, measurement: str) -> bool:
     locator = f".//logs/point_log[type='{measurement}']/updated_date"
     if (
         measurement in OBSOLETE_MEASUREMENTS
-        and (updated_date_key := xml.find(locator))
-        is not None
+        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")

{plugwise-1.6.3.dist-info → plugwise-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: plugwise
-Version: 1.6.3
+Version: 1.7.0
 Summary: Plugwise Smile (Adam/Anna/P1) and Stretch module for Python 3.
 Home-page: https://github.com/plugwise/python-plugwise
 Author: Plugwise device owners

plugwise-1.7.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+plugwise/__init__.py,sha256=fyot91I4cMkgo_8fL1hycRXwGBDecUq9ltxLAfSY-2U,17762
+plugwise/common.py,sha256=_41FLLjgccaHjaV0Ndn1YEkxjB_qKev1k3ZnhSUzXjc,9305
+plugwise/constants.py,sha256=Vd8tvOHsRtZxtUUFXBXolZj3QiKnxRt0bnwDT9DoEqE,17073
+plugwise/data.py,sha256=ITGnS5RiRbd3O2KbYLc9_5okw81zLl7azXNXtuTwaoY,13022
+plugwise/exceptions.py,sha256=Ce-tO9uNsMB-8FP6VAxBvsHNJ-NIM9F0onUZOdZI4Ys,1110
+plugwise/helper.py,sha256=dsdPpwJHiZ3DQoTc7kWoOiFVPvRda5u1GRJwAEDxuBk,39388
+plugwise/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugwise/smile.py,sha256=I8lssyqmq_PF8ptLxk3daS7lf20kXr5Z3L7SYg3S9j4,18928
+plugwise/smilecomm.py,sha256=aQ2KkebDTou18k-flrVmTnFkgls33Xu8D9ZZQQt2R5k,5178
+plugwise/util.py,sha256=7OPtC4FDbAweAqad6b-6tKtMlSSQd3OU7g5-0lplF34,11002
+plugwise/legacy/data.py,sha256=s2WYjgxwcuAGS8UOxJVf7xLSxS38Zgr8GsjxlxfD98w,3574
+plugwise/legacy/helper.py,sha256=GslPqZL0gAAnqJVy-Ydp_U-eGQ5jYhz9F_Y15BfQgt4,17056
+plugwise/legacy/smile.py,sha256=TxjqRf7KIecECt48iHgSFI7bIOEHNkf4desSBVo1l-M,11666
+plugwise-1.7.0.dist-info/LICENSE,sha256=mL22BjmXtg_wnoDnnaqps5_Bg_VGj_yHueX5lsKwbCc,1144
+plugwise-1.7.0.dist-info/METADATA,sha256=ZWR9Mhkp1CknISTs1adzs9jePeIWqW9M89qMnUyvGI8,9148
+plugwise-1.7.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+plugwise-1.7.0.dist-info/top_level.txt,sha256=MYOmktMFf8ZmX6_OE1y9MoCZFfY-L8DA0F2tA2IvE4s,9
+plugwise-1.7.0.dist-info/RECORD,,

{plugwise-1.6.3.dist-info → plugwise-1.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

plugwise-1.6.3.dist-info/RECORD

@@ -1,17 +0,0 @@
-plugwise/__init__.py,sha256=GzkiJTPI0vFUIjGcIlvL_KS1lIHad_cOIKzCXwY3Eaw,17183
-plugwise/common.py,sha256=vyiAbn5SJgcL5A9DYIj2ixHBbPO_6EFa16bK1VJ3In4,13040
-plugwise/constants.py,sha256=yTR9uxFyWi0S5-KDtUGbtMI3eb2dGC3ekMxvL8X0qEY,17203
-plugwise/data.py,sha256=kFdmCW9UEX7mqdBoGWH6TCiwb7vzdm-es5ZMwJsdBQA,12095
-plugwise/exceptions.py,sha256=Ce-tO9uNsMB-8FP6VAxBvsHNJ-NIM9F0onUZOdZI4Ys,1110
-plugwise/helper.py,sha256=v0sli2AE1s3ax0aAZoZw3Gmu7N9gImAol7S4l8FcuRY,45790
-plugwise/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-plugwise/smile.py,sha256=fyKo60PtOnW8bK3WpIu26R0mnXmHmsdjokTjVNS0j4A,19057
-plugwise/util.py,sha256=kt7JNcrTQaLT3eW_fzO4YmGsZzRull2Ge_OmHKl-rHk,8054
-plugwise/legacy/data.py,sha256=wHNcRQ_qF4A1rUdxn-1MoW1Z1gUwLqOvYvIkN6tJ_sk,3088
-plugwise/legacy/helper.py,sha256=ARIJytJNFiIR5G7Bp75DIULqgt56m0pxUXy6Ze8Te-4,18173
-plugwise/legacy/smile.py,sha256=RCQ0kHQwmPjq_G3r6aCe75RIvJt339jilzqEKydNopo,11286
-plugwise-1.6.3.dist-info/LICENSE,sha256=mL22BjmXtg_wnoDnnaqps5_Bg_VGj_yHueX5lsKwbCc,1144
-plugwise-1.6.3.dist-info/METADATA,sha256=OHR2k69qRTnfT8bl5jFpVRMiDDsnY7VCUgARvRKemCc,9148
-plugwise-1.6.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-plugwise-1.6.3.dist-info/top_level.txt,sha256=MYOmktMFf8ZmX6_OE1y9MoCZFfY-L8DA0F2tA2IvE4s,9
-plugwise-1.6.3.dist-info/RECORD,,