solarlog-cli 0.2.2__tar.gz → 0.3.1__tar.gz

{solarlog_cli-0.2.2 → solarlog_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solarlog_cli
-Version: 0.2.2
+Version: 0.3.1
 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.2.2 → solarlog_cli-0.3.1}/pyproject.toml

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

{solarlog_cli-0.2.2 → solarlog_cli-0.3.1}/src/solarlog_cli/solarlog_client.py

@@ -5,29 +5,47 @@ from __future__ import annotations
 import asyncio
 from datetime import datetime
 import json
+import logging
 from typing import Any
 
-from aiohttp import ClientSession, ClientTimeout
+from aiohttp import ClientResponse, ClientSession, ClientTimeout
 
-from .solarlog_exceptions import SolarLogConnectionError, SolarLogUpdateError
-from .solarlog_models import SolarlogData
+from .solarlog_exceptions import (
+    SolarLogAuthenticationError,
+    SolarLogConnectionError,
+    SolarLogUpdateError,
+)
 
-SOLARLOG_REQUEST_PAYLOAD = {801: {170: None}}
+from .solarlog_models import SolarlogData
 
+SOLARLOG_REQUEST_PAYLOAD = '{ "801": { "170": null } }'
+_LOGGER = logging.getLogger(__name__)
 
 class Client:
     """Client class to access Solar-Log."""
 
-    def __init__(self, host: str) -> None:
+    # pylint: disable=too-many-positional-arguments
+
+    def __init__(self, host: str, password: str = "") -> None:
         self.host: str = host
+        self.password: str = password
+        self.token: str = ""
+
+        self.request_timeout = 10
+        self.session = ClientSession(
+            timeout=ClientTimeout(total=self.request_timeout)
+        )
 
-        self.session: ClientSession = ClientSession()
         self._close_session: bool = True
 
-        self.request_timeout = 10
 
     async def test_connection(self) -> bool:
-        """Test the connection to Solar-Log"""
+        """Test the connection to Solar-Log."""
+        if self.session is None:
+            self.session = ClientSession(
+                timeout=ClientTimeout(total=self.request_timeout)
+            )
+            self._close_session = True
 
         url = f"{self.host}/getjp"
 
@@ -38,24 +56,55 @@ class Client:
 
         return False
 
-    async def execute_http_request(self, json_payload) -> dict[str, Any]:
-        """Hepler function to process the HTTP Get call."""
+    async def login(self) -> bool:
+        """Test the connection to Solar-Log."""
+
+        if self.password == "":
+            return False
+
+        payload: str = f"u=user&p={self.password}"
+
+        response = await self.execute_http_request(payload,"login")
+
+        text = await response.text()
+        if text.count("FAILED - Password was wrong"):
+            raise SolarLogAuthenticationError
+        if text.count("FAILED - User was wrong"):
+            #Response means, that no password is required
+            self.password = ""
+            return False
+
+        self.token = response.cookies["SolarLog"].value
+
+        _LOGGER.debug("response: %s",text)
+        _LOGGER.debug("cookies: %s",response.cookies)
+        _LOGGER.debug("Login successful, token: %s",self.token)
+
+        return True
+
+    async def execute_http_request(self, body: str, path: str = "getjp") -> ClientResponse:
+        """Helper function to process the HTTP Get call."""
         if self.session is None:
-            self.session = ClientSession()
+            self.session = ClientSession(
+                timeout=ClientTimeout(total=self.request_timeout)
+            )
             self._close_session = True
 
-        url = f"{self.host}/getjp"
+        url = f"{self.host}/{path}"
+
+        header = {"Content-Type": "text/html"}
+        if self.token != "":
+            header |= {"Cookie": f"SolarLog={self.token}"}
+            body = f"token={self.token}; " + body
 
-        header = {
-            "Content-Type": "application/json",
-        }
+        _LOGGER.debug("HTTP-request header: %s",header)
+        _LOGGER.debug("HTTP-request body: %s", body)
 
         try:
             response = await self.session.post(
                 url=url,
                 headers=header,
-                json=json_payload,
-                timeout=ClientTimeout(total=self.request_timeout)
+                data=body,
             )
         except asyncio.TimeoutError as exception:
             msg = f"Timeout occurred while connecting to Solar-Log at {self.host}"
@@ -65,14 +114,27 @@ class Client:
 
         if response.status != 200:
             # pylint: disable-next=line-too-long
-            msg = f"The server responded with error code {response.status} while fetching data from Solar-Log at {self.host}.\n{url}\n{header}\n{json_payload}"
+            msg = f"The server responded with error code {response.status} while fetching data from Solar-Log at {self.host}.\n{url}\n{header}\n{body}"
             text = await response.text()
             raise SolarLogUpdateError(
                 msg,
                 {"Content-Type": content_type, "response": text},
             )
 
+        _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()
+        _LOGGER.debug("Parsing http response: %s",text)
+
+        if text.count('{"QUERY IMPOSSIBLE 000"}'):
+            raise SolarLogUpdateError(f"Server response: {text}")
+
+        if text.count("ACCESS DENIED"):
+            raise SolarLogAuthenticationError(f"Server response: {text}")
 
         try:
             json_response = json.loads(text)
@@ -80,7 +142,7 @@ class Client:
             msg = f"Value error while decoding response: {err}."
             raise SolarLogUpdateError(
                 msg,
-                {"Content-Type": content_type, "Server response": text},
+                {"Server response": text},
             ) from err
 
         return json_response
@@ -88,7 +150,9 @@ class Client:
     async def get_basic_data(self) -> SolarlogData:
         """Get basic data from Solar-Log."""
 
-        raw_data: dict = await self.execute_http_request({801: {170: None}})
+        raw_data: dict[str, Any] = await self.parse_http_response(
+            await self.execute_http_request(SOLARLOG_REQUEST_PAYLOAD)
+        )
         raw_data = raw_data["801"]["170"]
 
         data = SolarlogData(
@@ -116,7 +180,9 @@ class Client:
     async def get_power_per_inverter(self) -> dict[int, float]:
         """Get power data from Solar-Log"""
 
-        raw_data: dict = await self.execute_http_request({782: None})
+        raw_data: dict = await self.parse_http_response(
+            await self.execute_http_request('{ "782": null }')
+        )
 
         data = {int(key): val for key, val in raw_data["782"].items() if val != "0"}
 
@@ -125,7 +191,9 @@ class Client:
     async def get_energy_per_inverter(self) -> dict[int, float]:
         """Get power data from Solar-Log"""
 
-        raw_data: dict = await self.execute_http_request({854: None})
+        raw_data: dict = await self.parse_http_response(
+            await self.execute_http_request('{ "854": null }')
+        )
         data_list = raw_data["854"][-1][-1]
 
         data: dict[int, float] = {}
@@ -139,10 +207,13 @@ class Client:
     async def get_energy(self, data: SolarlogData) -> SolarlogData:
         """Get energy data from Solar-Log"""
 
-        raw_data: dict = await self.execute_http_request({878: None})
+        raw_data: dict = await self.parse_http_response(
+            await self.execute_http_request('{ "878": null }')
+        )
 
-        data.production_year = raw_data["878"][-1][1]
-        data.self_consumption_year = raw_data["878"][-1][3]
+        if raw_data["878"] != "QUERY IMPOSSIBLE 000":
+            data.production_year = raw_data["878"][-1][1]
+            data.self_consumption_year = raw_data["878"][-1][3]
 
         return data
 
@@ -150,7 +221,9 @@ class Client:
         """Get list of all connected devices."""
 
         # get list of all inverters connected to Solar-Log
-        raw_data: dict = await self.execute_http_request({740: None})
+        raw_data: dict = await self.parse_http_response(
+            await self.execute_http_request('{ "740": null }')
+        )
         raw_data = raw_data["740"]
 
         device_list: dict[int, str] = {}
@@ -158,7 +231,11 @@ class Client:
         for key, value in raw_data.items():
             if value != "Err":
                 # get name of the inverter
-                raw_data = await self.execute_http_request({141: {key: {119: None}}})
+                raw_data = await self.parse_http_response(
+                    await self.execute_http_request(
+                        f"""{{ "141": {{ "{key}": {{ "119": null }} }} }}"""
+                    )
+                )
                 device_list |= {int(key): raw_data["141"][key]["119"]}
 
         return device_list

{solarlog_cli-0.2.2 → solarlog_cli-0.3.1}/src/solarlog_cli/solarlog_connector.py

@@ -5,7 +5,11 @@ import logging
 from zoneinfo import ZoneInfo
 
 from .solarlog_client import Client
-from .solarlog_exceptions import SolarLogUpdateError
+from .solarlog_exceptions import(
+    SolarLogAuthenticationError,
+    SolarLogConnectionError,
+    SolarLogUpdateError,
+)
 from .solarlog_models import SolarlogData, InverterData
 
 _LOGGER = logging.getLogger(__name__)
@@ -14,14 +18,18 @@ _LOGGER = logging.getLogger(__name__)
 class SolarLogConnector:
     """Connector class to access Solar-Log."""
 
+    # pylint: disable=too-many-arguments
+    # pylint: disable=too-many-positional-arguments
+
     def __init__(
         self,
         host: str,
         extended_data: bool = False,
         tz: str = "",
         device_enabled: dict[int, bool] | None = None,
+        password: str = "",
     ):
-        self.client = Client(host)
+        self.client = Client(host, password)
         self.extended_data: bool = extended_data
 
         self._device_list: dict[int, InverterData] = {}
@@ -38,6 +46,33 @@ class SolarLogConnector:
 
         return await self.client.test_connection()
 
+    async def test_extended_data_available(self) -> bool:
+        """Test if extended data is reachable."""
+
+        _LOGGER.debug("Start testing extended data available")
+
+        try:
+            await self.client.parse_http_response(
+                await self.client.execute_http_request('{"740": null}')
+            )
+        except (SolarLogConnectionError, SolarLogUpdateError) as err:
+            _LOGGER.debug("Error: %s", err)
+            return False
+        except SolarLogAuthenticationError as err:
+            #User has no unprotected access to extended API, try to log in
+            _LOGGER.debug("Authentication error: %s", err)
+            self.extended_data = await self.login()
+            _LOGGER.debug("Login successful?: %s", self.extended_data)
+        else:
+            self.extended_data = True
+
+        return self.extended_data
+
+    async def login(self) -> bool:
+        """Login to Solar-Log."""
+
+        return await self.client.login()
+
     async def update_data(self) -> SolarlogData:
         """Get data from Solar-Log."""
 
@@ -62,15 +97,15 @@ class SolarLogConnector:
         #calculated values (for downward compatibility)
         data.alternator_loss = data.power_dc - data.power_ac
         if data.power_dc != 0:
-            data.efficiency = round(data.power_ac / data.power_dc *100, 1)
+            data.efficiency = data.power_ac / data.power_dc *100
         if data.power_ac != 0:
-            data.usage = round(data.consumption_ac / data.power_ac * 100, 1)
+            data.usage = data.consumption_ac / data.power_ac * 100
             data.power_available = data.power_ac - data.consumption_ac
         else:
             data.usage = 0.0
             data.power_available = 0.0
         if data.total_power != 0:
-            data.capacity = round(data.power_dc / data.total_power * 100, 1)
+            data.capacity = data.power_dc / data.total_power * 100
 
         return data
 
@@ -117,6 +152,11 @@ class SolarLogConnector:
         """List of all devices of Solar-Log."""
         return self._device_list
 
+    @property
+    def password(self) -> str:
+        """Password for Solar-Log."""
+        return self.client.password
+
     def device(self, device_id: int) -> InverterData:
         """Get device data."""
         return self._device_list.get(device_id, InverterData())

solarlog_cli-0.3.1/src/solarlog_cli/solarlog_exceptions.py

@@ -0,0 +1,14 @@
+"""Exceptions for Python client for Solar-Log."""
+
+
+class SolarLogError(Exception):
+    """Generic SolarLog exception."""
+
+class SolarLogConnectionError(SolarLogError):
+    """SolarLog connection exception."""
+
+class SolarLogAuthenticationError(SolarLogError):
+    """Exception in login data."""
+
+class SolarLogUpdateError(SolarLogError):
+    """Exception in updating data."""

{solarlog_cli-0.2.2 → solarlog_cli-0.3.1}/src/solarlog_cli/solarlog_models.py

@@ -4,7 +4,6 @@ from datetime import datetime
 
 from mashumaro import DataClassDictMixin
 
-
 @dataclass
 class InverterData():
     """Inverter Data model."""

{solarlog_cli-0.2.2 → solarlog_cli-0.3.1}/tests/__snapshots__/test_solarlog_cli.ambr

@@ -2,14 +2,14 @@
 # name: test_update_data[asyncio]
   dict({
     'alternator_loss': 100,
-    'capacity': 27.9,
+    'capacity': 27.901119402985074,
     'consumption_ac': 3110,
     'consumption_day': 47819,
     'consumption_month': 697471,
     'consumption_total': 28385247,
     'consumption_year': 4218251,
     'consumption_yesterday': 94350,
-    'efficiency': 96.7,
+    'efficiency': 96.65663657639585,
     'inverter_data': dict({
       0: dict({
         'consumption_year': 4227027.0,
@@ -43,7 +43,7 @@
     'production_year': 8852462,
     'self_consumption_year': 2071,
     'total_power': 10720,
-    'usage': 107.6,
+    'usage': 107.5752334832238,
     'voltage_ac': 0,
     'voltage_dc': 492,
     'yield_day': 17490,

solarlog_cli-0.3.1/tests/fixtures/device_list_access_denied.json

@@ -0,0 +1,9 @@
+{
+    "740": {
+        "0":"ACCESS DENIED",
+        "1":"ACCESS DENIED",
+        "2":"ACCESS DENIED",
+        "3":"ACCESS DENIED",
+        "4":"ACCESS DENIED"
+    }
+}

{solarlog_cli-0.2.2 → solarlog_cli-0.3.1}/tests/test_solarlog_cli.py

@@ -7,6 +7,7 @@ from syrupy.assertion import SnapshotAssertion
 
 from solarlog_cli.solarlog_connector import SolarLogConnector
 from solarlog_cli.solarlog_exceptions import (
+    SolarLogAuthenticationError,
     SolarLogConnectionError,
     SolarLogError,
     SolarLogUpdateError,
@@ -35,6 +36,8 @@ async def test_connection(
 
     solarlog_connector = SolarLogConnector("localhost")
 
+    await solarlog_connector.client.close()
+    solarlog_connector.client.session = None  # type: ignore [assignment]
     assert await solarlog_connector.test_connection() == return_value
 
     assert solarlog_connector.host == "localhost"
@@ -45,6 +48,92 @@ async def test_connection(
     assert solarlog_connector.client.session.closed
 
 
+async def test_extended_data_available(
+    responses: aioresponses,
+) -> None:
+    """Test extended data available."""
+
+    solarlog_connector = SolarLogConnector("http://solarlog.com", password="pwd")
+
+    responses.post(
+        "http://solarlog.com/getjp",
+        timeout=True,
+    )
+    assert not await solarlog_connector.test_extended_data_available()
+
+    responses.post(
+        "http://solarlog.com/getjp",
+        status=400,
+    )
+    assert not await solarlog_connector.test_extended_data_available()
+
+    responses.post(
+        "http://solarlog.com/getjp",
+        body=load_fixture("device_list_access_denied.json"),
+    )
+    responses.post(
+        "http://solarlog.com/login",
+        body="FAILED - User was wrong",
+    )
+    assert not await solarlog_connector.test_extended_data_available()
+    assert solarlog_connector.password == ""
+
+    responses.post(
+        "http://solarlog.com/getjp",
+        body=load_fixture("device_list.json"),
+    )
+    assert await solarlog_connector.test_extended_data_available()
+
+    await solarlog_connector.client.close()
+    assert solarlog_connector.client.session.closed
+
+async def test_login_and_data_retreival(responses: aioresponses) -> None:
+    """Test login into Solar-Log."""
+    responses.post(
+        "http://solarlog.com/login",
+        headers={"Set-Cookie": "SolarLog=token"},
+        body="SUCCESS - Password was correct, you are now logged in",
+    )
+    solarlog_connector = SolarLogConnector("http://solarlog.com", password="pwd")
+
+    assert await solarlog_connector.login()
+    assert solarlog_connector.client.token == "token"
+
+    responses.post(
+        "http://solarlog.com/getjp",
+        body=load_fixture("basic_data.json"),
+    )
+    await solarlog_connector.update_data()
+
+    await solarlog_connector.client.close()
+    assert solarlog_connector.client.session.closed
+
+async def test_login_exceptions(responses: aioresponses) -> None:
+    """Test exceptions at login into Solar-Log."""
+    solarlog_connector = SolarLogConnector("http://solarlog.com", password="pwd")
+
+    responses.post(
+        "http://solarlog.com/login",
+        body="FAILED - Password was wrong",
+    )
+    with pytest.raises(SolarLogAuthenticationError):  # type: ignore [call-overload]
+        await solarlog_connector.client.login()
+
+    responses.post(
+        "http://solarlog.com/login",
+        body="FAILED - User was wrong",
+    )
+    assert not await solarlog_connector.client.login()
+
+    responses.post(
+        "http://solarlog.com/getjp",
+        body=load_fixture("device_list.json"),
+    )
+    assert not await solarlog_connector.client.login()
+
+    await solarlog_connector.client.close()
+    assert solarlog_connector.client.session.closed
+
 async def test_update_data(
     responses: aioresponses,
     snapshot: SnapshotAssertion
@@ -126,6 +215,10 @@ async def test_update_data_with_data_exceptions(
         "http://solarlog.com/getjp",
         body="",
     )
+    responses.post(
+        "http://solarlog.com/getjp",
+        body='{"QUERY IMPOSSIBLE 000"}',
+    )
     responses.post(
         "http://solarlog.com/getjp",
         body=load_fixture("basic_data_during_update.json"),
@@ -143,6 +236,9 @@ async def test_update_data_with_data_exceptions(
     with pytest.raises(SolarLogUpdateError):
         await solarlog_connector.update_data()
 
+    with pytest.raises(SolarLogUpdateError):
+        await solarlog_connector.update_data()
+
     data = await solarlog_connector.update_data()
 
     assert data.usage == 0

solarlog_cli-0.2.2/src/solarlog_cli/solarlog_exceptions.py

@@ -1,11 +0,0 @@
-"""Exceptions for Python client for Solar-Log."""
-
-
-class SolarLogError(Exception):
-    """Generic exception."""
-
-class SolarLogConnectionError(SolarLogError):
-    """Analytics connection exception."""
-
-class SolarLogUpdateError(SolarLogError):
-    """Analytics connection exception."""