solarlog-cli 0.7.0__tar.gz → 0.7.2__tar.gz

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/.devcontainer/devcontainer.json

@@ -3,10 +3,10 @@
 {
 	"name": "Docker in Docker",
 	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-	"image": "mcr.microsoft.com/devcontainers/base:bullseye",
+	"image": "mcr.microsoft.com/devcontainers/python:3-3.14-bookworm",
 
 	"features": {
-		"ghcr.io/devcontainers/features/docker-in-docker:2": {
+		"ghcr.io/devcontainers/features/docker-in-docker:4.1.3": {
 			"moby": true,
 			"azureDnsAutoDetection": true,
 			"installDockerBuildx": true,
@@ -24,7 +24,7 @@
 		"ghcr.io/devcontainers-community/npm-features/prettier:1": {
 			"version": "latest"
 		},
-		"ghcr.io/hspaans/devcontainer-features/pytest:1": {
+		"ghcr.io/hspaans/devcontainer-features/pytest:2.0.0": {
 			"version": "latest",
 			"plugins": "pytest-testinfra"
 		}

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/.github/workflows/python-publish.yml

@@ -33,7 +33,7 @@ jobs:
     - name: Build package
       run: python -m build
     - name: Publish package
-      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      uses: pypa/gh-action-pypi-publish@release/v1
       with:
         user: __token__
         password: ${{ secrets.PYPI_API_TOKEN }}

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/.github/workflows/tests.yml

@@ -30,7 +30,7 @@ jobs:
       - name: 🏗 Install dependencies
         run: python3 -m pip install -r requirements.txt
       - name: 🏗 Install pytest
-        run: python3 -m pip install pytest pytest-cov pytest-aio
+        run: python3 -m pip install pytest pytest-cov pytest-asyncio
       - name: 🚀 Run pytest
         run: pytest --cov src tests
       - name: ⬆️ Upload coverage artifact

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/.gitignore

@@ -1,5 +1,6 @@
 src/solarlog_cli/__pycache__
 tests/__pycache__
+.coverage
 .mypy_cache
 .pytest_cache
 .gitignore

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: solarlog_cli
-Version: 0.7.0
+Version: 0.7.2
 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
@@ -14,7 +14,7 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 or later (G
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.12
-Requires-Dist: aiohttp
+Requires-Dist: aiohttp>=3.14.0
 Requires-Dist: bcrypt>=4.3.0
 Requires-Dist: mashumaro>=3.13
 Description-Content-Type: text/markdown

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "solarlog_cli"
-version = "0.7.0"
+version = "0.7.2"
 authors = [
   { name="dontinelli", email="73341522+dontinelli@users.noreply.github.com" },
 ]
@@ -8,7 +8,7 @@ description = "Python library to access the Solar-Log"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-  "aiohttp",
+  "aiohttp>=3.14.0",
   "bcrypt>=4.3.0",
   "mashumaro>=3.13",
 ]

solarlog_cli-0.7.2/pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+pythonpath = src
+asyncio_mode = auto

solarlog_cli-0.7.2/requirements.txt

@@ -0,0 +1,6 @@
+aiohttp>=3.14.0
+aiointercept[pytest-asyncio] == 1.0.0
+bcrypt >= 4.3.0
+mashumaro>=3.13
+pytest-cov==5.0.0
+syrupy == 4.6.1

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/src/solarlog_cli/solarlog_client.py

@@ -2,22 +2,21 @@
 
 from __future__ import annotations
 
-import asyncio
-from datetime import datetime
 import json
 import logging
+from datetime import UTC, date, datetime, tzinfo
 from typing import Any
+from zoneinfo import ZoneInfo
 
-from aiohttp import ClientResponse, ClientSession, ClientTimeout
 import bcrypt
+from aiohttp import ClientResponse, ClientSession, ClientTimeout
 
 from .solarlog_exceptions import (
     SolarLogAuthenticationError,
     SolarLogConnectionError,
     SolarLogUpdateError,
 )
-
-from .solarlog_models import EnergyData, SolarlogData
+from .solarlog_models import EnergyData, EventData, SolarlogData
 
 SOLARLOG_REQUEST_PAYLOAD = '{ "801": { "170": null } }'
 _LOGGER = logging.getLogger(__name__)
@@ -27,10 +26,15 @@ class Client:
     """Client class to access Solar-Log."""
 
     # pylint: disable=too-many-positional-arguments
+    # pylint: disable=too-many-instance-attributes
+
+    def __init__(
+            self, host: str, session: ClientSession | None, password: str = "", tz: str = ""
+        ) -> None:
 
-    def __init__(self, host: str, session: ClientSession | None, password: str = "") -> None:
         self.host: str = host
         self.password: str = password
+        self.timezone: tzinfo = UTC if tz == "" else ZoneInfo(tz)
 
         self.request_timeout = 30
 
@@ -41,6 +45,7 @@ class Client:
 
         self._hashed_pwd: bool = False
         self._close_session: bool = True
+        self._token = ""  # required for older firmware, where cookie is not sufficient
 
     async def test_connection(self) -> bool:
         """Test the connection to Solar-Log."""
@@ -55,13 +60,10 @@ class Client:
             timeout=ClientTimeout(total=self.request_timeout)
         )
 
-        if response.status == 200:
-            return True
-
-        return False
+        return response.status == 200
 
     async def login(self) -> bool:
-        """Test the connection to Solar-Log."""
+        """Login to Solar-Log."""
 
         if self.password == "":
             return False
@@ -71,7 +73,7 @@ class Client:
         response = await self.execute_http_request(payload, "login")
 
         text = await response.text()
-        _LOGGER.debug("Response: %s", text)
+        _LOGGER.debug("Response to request for login: %s", text)
         if text.count("FAILED - User was wrong"):
             # Response means, that no password is required
             self.password = ""
@@ -114,6 +116,9 @@ class Client:
         self.session.cookie_jar.update_cookies(
             {"SolarLog": response.cookies["SolarLog"].value})
 
+        if not self._hashed_pwd:
+            self._token = response.cookies["SolarLog"].value
+
         _LOGGER.debug("response: %s", text)
         _LOGGER.debug("cookies: %s", response.cookies)
         _LOGGER.debug("Login successful, token: %s",
@@ -121,7 +126,7 @@ class Client:
 
         return True
 
-    async def execute_http_request(self, body: str, path: str = "getjp", timeout: float | None = None) -> ClientResponse: # pylint: disable=line-too-long
+    async def execute_http_request(self, body: str, path: str = "getjp", timeout: float | None = None) -> ClientResponse:  # pylint: disable=line-too-long
         """Helper function to process the HTTP Get call."""
         if self.session is None:
             self.session = ClientSession()
@@ -131,8 +136,11 @@ class Client:
 
         header = {"Content-Type": "text/html", "X-SL-CSRF-PROTECTION": "1"}
 
-        _LOGGER.debug("HTTP-request header: %s", header)
-        _LOGGER.debug("HTTP-request body: %s", body)
+        if self._token != "":
+            body = f"token={self._token}; " + body
+
+        # _LOGGER.debug("HTTP-request header: %s", header)
+        # _LOGGER.debug("HTTP-request body: %s", body)
 
         try:
             response = await self.session.post(
@@ -141,7 +149,7 @@ class Client:
                 data=body,
                 timeout=ClientTimeout(total=timeout or self.request_timeout),
             )
-        except asyncio.TimeoutError as exception:
+        except TimeoutError as exception:
             msg = f"Timeout occurred while connecting to Solar-Log at {self.host}"
             raise SolarLogConnectionError(msg) from exception
 
@@ -156,14 +164,14 @@ class Client:
                 {"Content-Type": content_type, "response": text},
             )
 
-        _LOGGER.debug("HTTP-request successful: %s", response)
+        # _LOGGER.debug("HTTP-request successful: %s", response)
         return response
 
     async def parse_http_response(self, response: ClientResponse) -> dict[str, Any]:
         """Helper function to parse the HTTP response."""
 
         text = await response.text(errors="replace")
-        _LOGGER.debug("Parsing http response: %s", text)
+        # _LOGGER.debug("Parsing http response: %s", text)
 
         if text.count('{"QUERY IMPOSSIBLE 000"}'):
             raise SolarLogUpdateError(f"Server response: {text}")
@@ -192,7 +200,7 @@ class Client:
 
         data = SolarlogData(
             last_updated=datetime.strptime(
-                raw_data["100"], "%d.%m.%y %H:%M:%S"),
+                raw_data["100"], "%d.%m.%y %H:%M:%S").astimezone(self.timezone),
             power_ac=raw_data["101"],
             power_dc=raw_data["102"],
             voltage_ac=raw_data["103"],
@@ -214,7 +222,7 @@ class Client:
         return data
 
     async def get_battery_data(self, timeout: float | None = None) -> list[float]:
-        """Get battery data from Solar-Log"""
+        """Get battery data from Solar-Log."""
 
         raw_data: dict = await self.parse_http_response(
             await self.execute_http_request('{ "858": null }', timeout=timeout)
@@ -225,7 +233,7 @@ class Client:
         return data
 
     async def get_power_per_inverter(self, timeout: float | None = None) -> dict[int, float]:
-        """Get power data from Solar-Log"""
+        """Get power data from Solar-Log."""
 
         raw_data: dict = await self.parse_http_response(
             await self.execute_http_request('{ "782": null }', timeout=timeout)
@@ -237,7 +245,7 @@ class Client:
         return data
 
     async def get_energy_per_inverter(self, timeout: float | None = None) -> dict[int, float]:
-        """Get power data from Solar-Log"""
+        """Get power data from Solar-Log."""
 
         raw_data: dict = await self.parse_http_response(
             await self.execute_http_request('{ "854": null }', timeout=timeout)
@@ -253,7 +261,7 @@ class Client:
         return data
 
     async def get_energy(self, timeout: float | None = None) -> EnergyData | None:
-        """Get energy data from Solar-Log"""
+        """Get energy data from Solar-Log."""
 
         raw_data: dict = await self.parse_http_response(
             await self.execute_http_request('{ "878": null }', timeout=timeout)
@@ -267,8 +275,26 @@ class Client:
 
         return None
 
-    async def get_device_list(self, timeout: float | None = None) -> dict[int, str]:
-        """Get list of all connected devices."""
+    async def get_firmware(self, timeout: float | None = None) -> tuple[str, date]:
+        """Get firmware data from Solar-Log."""
+
+        raw_data: dict = await self.parse_http_response(
+            await self.execute_http_request(
+                '{ "801": {"101" : None, "102" : None } }', timeout=timeout
+            )
+        )
+        fw_version: str = raw_data["801"]["101"]
+        fw_date: date = datetime.strptime(
+            raw_data["801"]["102"], "%d.%m.%Y").date()
+
+        return (fw_version, fw_date)
+
+    async def get_device_list(
+            self,
+            timeout: float | None = None
+        ) -> dict[int, tuple[str, dict, dict]]:
+        """Get list of all connected devices.
+        Return value is a dict with name, possible events and error codes per device."""
 
         # get list of all inverters connected to Solar-Log
         raw_data: dict = await self.parse_http_response(
@@ -276,20 +302,54 @@ class Client:
         )
         raw_data = raw_data["740"]
 
-        device_list: dict[int, str] = {}
+        device_list: dict[int, tuple[str, dict, dict]] = {}
 
         for key, value in raw_data.items():
             if value != "Err":
-                # get name of the inverter
+                # get name, events and error codes of the inverter
+                query = (
+                    f'{{ "141": {{ "{key}": {{ "119": null, "708": null, '
+                    f'"709": null }} }} }}'
+                )
                 raw_data = await self.parse_http_response(
-                    await self.execute_http_request(
-                        f"""{{ "141": {{ "{key}": {{ "119": null }} }} }}""", timeout=timeout
-                    )
+                    await self.execute_http_request(query, timeout=timeout)
                 )
-                device_list |= {int(key): raw_data["141"][key]["119"]}
+                device_list |= {int(key): (
+                        raw_data["141"][key]["119"],
+                        raw_data["141"][key]["708"],
+                        raw_data["141"][key]["709"],
+                    )
+                }
 
         return device_list
 
+    async def get_device_last_event(self, device: int, timeout: float | None = None) -> EventData:
+        """Get list of last event/error of a device."""
+
+        raw_data = await self.parse_http_response(
+            await self.execute_http_request(
+                f"""{{ "141": {{ "{device}": {{ "710": null }} }} }}""", timeout=timeout
+            )
+        )
+        print(raw_data)
+        events = raw_data["141"][str(device)]["710"]["0"]
+
+        return EventData(
+            start=datetime.fromtimestamp(events[0][0]),
+            end=datetime.fromtimestamp(events[0][1]),
+            event=int(events[0][3]),
+            error=int(events[0][4])
+        )
+
+    async def get_status_per_device(self, timeout: float | None = None) -> dict[int, str]:
+        """Get inverter status from Solar-Log"""
+
+        raw_data: dict = await self.parse_http_response(
+            await self.execute_http_request('{ "608": null }', timeout=timeout)
+        )
+        print(raw_data)
+        return raw_data["608"]
+
     async def close(self) -> None:
         """Close open client session."""
         if self.session and self._close_session:

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/src/solarlog_cli/solarlog_connector.py

@@ -1,13 +1,12 @@
 """Connector class to manage access to Solar-Log."""
 
-from datetime import timezone, tzinfo
 import logging
-from zoneinfo import ZoneInfo
+from datetime import date
 
 from aiohttp import ClientSession
 
 from .solarlog_client import Client
-from .solarlog_exceptions import(
+from .solarlog_exceptions import (
     SolarLogAuthenticationError,
     SolarLogConnectionError,
     SolarLogUpdateError,
@@ -26,13 +25,15 @@ class SolarLogConnector:
     def __init__(
         self,
         host: str,
+        auto_fw_update: bool = False,
         extended_data: bool = False,
         tz: str = "",
         device_enabled: dict[int, bool] | None = None,
         password: str = "",
         session: ClientSession | None = None,
     ):
-        self.client = Client(host, session, password)
+        self.client = Client(host, session, password, tz)
+        self.auto_fw_update: bool = auto_fw_update
         self.extended_data: bool = extended_data
 
         self._device_list: dict[int, InverterData] = {}
@@ -42,7 +43,6 @@ class SolarLogConnector:
         for key, value in device_enabled.items():
             self._device_list |= {key: InverterData(enabled=value)}
 
-        self.timezone: tzinfo = timezone.utc if tz == "" else ZoneInfo(tz)
 
     async def test_connection(self) -> bool:
         """Test if connection to Solar-Log works."""
@@ -98,6 +98,12 @@ class SolarLogConnector:
 
             data.battery_data = await self.update_battery_data()
 
+            if self.auto_fw_update:
+                (
+                    data.firmware_version,
+                    data.firmware_release_date,
+                ) = await self.update_firmware_information()
+
             _LOGGER.debug("Extended data updated: %s",data)
 
         return data
@@ -112,8 +118,6 @@ class SolarLogConnector:
                 "Invalid data returned (can happen after Solarlog restart)."
             )
 
-        data.last_updated = data.last_updated.replace(tzinfo=self.timezone)
-
         _LOGGER.debug("Basic data updated: %s",data)
 
         #calculated values (for downward compatibility)
@@ -124,7 +128,7 @@ class SolarLogConnector:
             data.usage = data.consumption_ac / data.power_ac * 100
             data.power_available = data.power_ac - data.consumption_ac
         else:
-            data.usage = 0.0
+            data.usage = None
             data.power_available = 0.0
         if data.total_power != 0:
             data.capacity = data.power_dc / data.total_power * 100
@@ -164,27 +168,46 @@ class SolarLogConnector:
         devices = await self.client.get_device_list(timeout)
 
         self._device_list = {
-            key: InverterData(name=value,enabled=self.device(key).enabled)
+            key: InverterData(
+                name=value[0],
+                enabled=self.device(key).enabled,
+                errors=value[2],
+                events=value[1]
+                )
             for key, value in devices.items()
         }
-        _LOGGER.debug("Device list: %s",self._device_list)
+        _LOGGER.debug("Device list updated: %s",self._device_list)
 
         return self._device_list
 
+    async def update_firmware_information(self, timeout: float | None = None) -> tuple[str, date]:
+        """Update firmware data (version and release date)."""
+
+        return await self.client.get_firmware(timeout)
+
     async def update_inverter_data(self, timeout: float | None = None) -> dict[int, InverterData]:
         """Update device specific data."""
 
-        raw_data = await self.client.get_power_per_inverter(timeout)
-        for key, value in raw_data.items():
+        raw_power_data = await self.client.get_power_per_inverter(timeout)
+        for key, value in raw_power_data.items():
             key = int(key)
             if self._device_list.get(key,InverterData).enabled:
                 self._device_list[key].current_power = float(value)
 
-        raw_data = await self.client.get_energy_per_inverter(timeout)
-        for key, value in raw_data.items():
+        raw_energy_data = await self.client.get_energy_per_inverter(timeout)
+        for key, value in raw_energy_data.items():
+            key = int(key)
             if self._device_list.get(key,InverterData).enabled:
                 self._device_list[key].consumption_year = float(value)
 
+        raw_status_data = await self.client.get_status_per_device(timeout)
+        for key, str_value in raw_status_data.items():
+            key = int(key)
+            if self._device_list.get(key,InverterData).enabled:
+                self._device_list[key].status = str_value
+
+                self._device_list[key].last_event = await self.client.get_device_last_event(key)
+
         _LOGGER.debug("Inverter data updated: %s",self._device_list)
 
         return self._device_list

{solarlog_cli-0.7.0 → solarlog_cli-0.7.2}/src/solarlog_cli/solarlog_models.py

@@ -1,11 +1,12 @@
 """Models for SolarLog."""
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import date, datetime
 
 from mashumaro import DataClassDictMixin
 
+
 @dataclass
-class BatteryData():
+class BatteryData:
     """Battery Data model."""
 
     charge_power: float = 0
@@ -14,20 +15,34 @@ class BatteryData():
     voltage: float = 0
 
 @dataclass
-class EnergyData():
+class EnergyData:
     """Energy Data model."""
 
     production: float | None = None
     self_consumption: float | None = None
 
 @dataclass
-class InverterData():
+class EventData:
+    """Event Data model."""
+
+    end: datetime
+    error: int
+    event: int
+    start: datetime
+
+@dataclass
+class InverterData:
     """Inverter Data model."""
+    # pylint: disable=too-many-instance-attributes
 
     name: str = ""
-    enabled: bool = False
-    current_power: float | None = None
     consumption_year: float | None = None
+    current_power: float | None = None
+    enabled: bool = False
+    errors: dict[int,str] = field(default_factory=dict)
+    events: dict[int,str] = field(default_factory=dict)
+    last_event: EventData | None = None
+    status: str | None = None
 
 
 @dataclass
@@ -63,6 +78,8 @@ class SolarlogData(DataClassDictMixin):
 
     #extended data
     battery_data: BatteryData | None = None
+    firmware_release_date: date | None = None
+    firmware_version: str | None = None
     inverter_data: dict[int, InverterData] = field(default_factory=dict)
     production_year: float | None = None
     self_consumption_year: float | None = None