solarlog-cli 0.1.4__tar.gz → 0.1.6__tar.gz

{solarlog_cli-0.1.4 → solarlog_cli-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solarlog_cli
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python library to access the Solar-Log
 Project-URL: Repository, https://github.com/dontinelli/solarlog_cli.git
 Project-URL: Issues, https://github.com/dontinelli/solarlog_cli/issues

{solarlog_cli-0.1.4 → solarlog_cli-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "solarlog_cli"
-version = "0.1.4"
+version = "0.1.6"
 authors = [
   { name="dontinelli", email="73341522+dontinelli@users.noreply.github.com" },
 ]

{solarlog_cli-0.1.4 → solarlog_cli-0.1.6}/src/solarlog_cli/solarlog_client.py

@@ -20,7 +20,7 @@ _LOGGER = logging.getLogger(__name__)
 class Client:
     """Client class to access Solar-Log."""
 
-    def __init__(self, host: str):
+    def __init__(self, host: str) -> None:
         self.host: str = host
 
         self.session: ClientSession = ClientSession()
@@ -85,7 +85,7 @@ class Client:
 
         return json_response
 
-    async def get_basic_data(self) -> dict[str, Any]:
+    async def get_basic_data(self) -> dict[str, int | float | datetime]:
         """Get basic data from Solar-Log."""
 
         raw_data: dict = await self.execute_http_request({801: {170: None}})

{solarlog_cli-0.1.4 → solarlog_cli-0.1.6}/src/solarlog_cli/solarlog_connector.py

@@ -1,12 +1,14 @@
 """Connector class to manage access to Solar-Log."""
 
-from datetime import timezone
-from typing import Any
+from datetime import datetime, timezone
+import logging
 from zoneinfo import ZoneInfo
 
 from .solarlog_client import Client
 from .solarlog_exceptions import SolarLogUpdateError
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class SolarLogConnector:
     """Connector class to access Solar-Log."""
@@ -30,10 +32,10 @@ class SolarLogConnector:
 
         return await self.client.test_connection()
 
-    async def update_data(self) -> dict[str, Any]:
+    async def update_data(self) -> dict[str, int | float | datetime]:
         """Get data from Solar-Log."""
 
-        data: dict = await self.client.get_basic_data()
+        data: dict[str, int | float | datetime] = await self.client.get_basic_data()
 
         if data["last_updated"].year == 1999:
             raise SolarLogUpdateError(
@@ -42,14 +44,15 @@ class SolarLogConnector:
 
         data["last_updated"] = data["last_updated"].replace(tzinfo=self.timezone)
 
-        # print(f"basic data updated: {data}")
+        _LOGGER.debug("Basic data updated: %s",data)
         if self.extended_data:
             data |= await self.client.get_energy()
             if self._device_enabled != {} and self._device_enabled is not None:
                 data |= {"devices": await self.update_inverter_data()}
-            # print(f"extended data updated: {data}")
+            _LOGGER.debug("Extended data updated: %s",data)
 
         #calculated values (for downward compatibility)
+        data |= {"alternator_loss": data.get("power_dc") - data.get("power_ac")}
         if data.get("power_dc") != 0:
             data |= {"efficiency": data.get("power_ac") / data.get("power_dc")}
         if data.get("power_ac") != 0:
@@ -58,10 +61,8 @@ class SolarLogConnector:
         else:
             data |= {"usage": 0.0}
             data |= {"power_available": 0.0}
-        data |= {"alternator_loss": data.get("power_dc") - data.get("power_ac")}
-
         if data.get("total_power") != 0:
-            data |= {"capacity": - data.get("power_dc") / data.get("total_power")}
+            data |= {"capacity": data.get("power_dc") / data.get("total_power")}
 
         return data
 
@@ -74,32 +75,28 @@ class SolarLogConnector:
 
         for key, value in self._device_enabled.items():
             device_list[int(key)] |= {"enabled": value}
-        # print(f"device list: {device_list}")
+        _LOGGER.debug("Device list: %s",device_list)
         self._device_list = device_list
 
         return device_list
 
-    async def update_inverter_data(self) -> dict[int, dict[str, Any]]:
+    async def update_inverter_data(self) -> dict[int, dict[str, float]]:
         """Update device specific data."""
-        data: dict[int, dict[str, Any]] = {}
-        # print(self._device_enabled)
+        data: dict[int, dict[str, float]] = {}
         raw_data = await self.client.get_power_per_inverter()
-        # print(f"power: {raw_data}")
         for key, value in raw_data.items():
             key = int(key)
             if self._device_enabled.get(key, False):
                 data |= {key: {"current_power": float(value)}}
 
         raw_data = await self.client.get_energy_per_inverter()
-        # print(f"energy: {raw_data}")
         for key, value in raw_data.items():
-            # print(f"key: {key}, value: {value}, enabled: {self._device_enabled[key]}")
             if self._device_enabled[key]:
                 if key in data:
                     data[key].update({"consumption_year": float(value)})
                 else:
                     data |= {key: {"consumption_year": float(value)}}
-        # print(data)
+        _LOGGER.debug("Inverter data updated: %s",data)
 
         return data
 
@@ -115,7 +112,7 @@ class SolarLogConnector:
 
     def device_name(self, device_id: int) -> str:
         """Get name of Solar-Log attached device."""
-        print(f"list: {self._device_list}, id: {device_id}")
+        _LOGGER.debug("Device list: %s; id: %s",self._device_list, device_id)
         if device_id in self._device_list:
             return self._device_list[device_id]["name"]
 
@@ -126,3 +123,7 @@ class SolarLogConnector:
         if device_id is None:
             return self._device_enabled
         return self._device_enabled[device_id]
+
+    def set_enabled_devices(self, device_enabled: dict[int, bool]) -> None:
+        """Set enabled devices."""
+        self._device_enabled = device_enabled

solarlog_cli-0.1.4/src/solarlog_cli/utils.py

@@ -1,58 +0,0 @@
-"""Utility functions for the FYTA integration."""
-
-
-def safe_get(plant_data, key_path, expected_type):
-    """Get a value from a nested dictionary and cast it to the expected type.
-
-    Args:
-        plant_data: The dictionary to get the value from.
-        key_path: The path to the value in the dictionary. Seüarated by dots.
-        expected_type: The expected type of the value (int, float, bool and str supported).
-
-    Returns: The value from the dictionary or None if the value is not found or the type is not
-    as expected.
-    """
-    keys = key_path.split(".")
-    value = plant_data
-    try:
-        for key in keys:
-            value = value.get(key)
-            if value is None:
-                return None
-    except AttributeError:
-        return None
-    return_value = None
-    if expected_type == int:
-        return_value = __get_int(value)
-    if expected_type == float:
-        return_value =  __get_float(value)
-    if expected_type == bool:
-        return_value = __get_bool(value)
-    if expected_type == str:
-        return_value = str(value)
-    return return_value
-
-
-def __get_bool(value):
-    if isinstance(value, bool):
-        return value
-    if isinstance(value, str):
-        if value.lower() == "true":
-            return True
-        if value.lower() == "false":
-            return False
-    return None
-
-
-def __get_float(value):
-    try:
-        return float(value)
-    except (ValueError, TypeError):
-        return None
-
-
-def __get_int(value):
-    try:
-        return int(value)
-    except (ValueError, TypeError):
-        return None