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

{solarlog_cli-0.6.0 → solarlog_cli-0.7.0}/.github/workflows/pylint.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.12"]
+        python-version: ["3.13"]
     steps:
     - name: ⤵️ Checkout the repository
       uses: actions/checkout@v4.1.7

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

@@ -25,7 +25,7 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v3
       with:
-        python-version: '3.12'
+        python-version: '3.13'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

{solarlog_cli-0.6.0 → solarlog_cli-0.7.0}/.github/workflows/ruff.yml

@@ -18,7 +18,7 @@ jobs:
         - name: 🏗 Set up Python
           uses: actions/setup-python@v5.0.0
           with:
-            python-version: "3.12"
+            python-version: "3.13"
             cache: "pip"
         - name: 🏗 Install requirements
           run: python3 -m pip install -r requirements.txt

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

@@ -9,7 +9,7 @@ on:
   workflow_dispatch:
 
 env:
-  DEFAULT_PYTHON: "3.12"
+  DEFAULT_PYTHON: "3.13"
 
 jobs:
   pytest:
@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python: ["3.12"]
+        python: ["3.13"]
     steps:
       - name: ⤵️ Check out code from GitHub
         uses: actions/checkout@v4.1.7

{solarlog_cli-0.6.0 → solarlog_cli-0.7.0}/.github/workflows/typing.yml

@@ -10,7 +10,7 @@ on:
             - main
 
 env:
-    DEFAULT_PYTHON: "3.12"
+    DEFAULT_PYTHON: "3.13"
 
 jobs:
     mypy:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solarlog_cli
-Version: 0.6.0
+Version: 0.7.0
 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.6.0 → solarlog_cli-0.7.0}/pyproject.toml

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

{solarlog_cli-0.6.0 → solarlog_cli-0.7.0}/requirements.txt

@@ -1,4 +1,4 @@
-aiohttp>=3.9.5
+aiohttp>=3.13.3
 aioresponses == 0.7.6
 bcrypt >= 4.3.0
 mashumaro>=3.13

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

@@ -17,11 +17,12 @@ from .solarlog_exceptions import (
     SolarLogUpdateError,
 )
 
-from .solarlog_models import SolarlogData
+from .solarlog_models import EnergyData, SolarlogData
 
 SOLARLOG_REQUEST_PAYLOAD = '{ "801": { "170": null } }'
 _LOGGER = logging.getLogger(__name__)
 
+
 class Client:
     """Client class to access Solar-Log."""
 
@@ -30,7 +31,6 @@ class Client:
     def __init__(self, host: str, session: ClientSession | None, password: str = "") -> None:
         self.host: str = host
         self.password: str = password
-        self.token: str = ""
 
         self.request_timeout = 30
 
@@ -39,9 +39,9 @@ class Client:
         else:
             self.session = session
 
+        self._hashed_pwd: bool = False
         self._close_session: bool = True
 
-
     async def test_connection(self) -> bool:
         """Test the connection to Solar-Log."""
         if self.session is None:
@@ -68,12 +68,12 @@ class Client:
 
         payload: str = f"u=user&p={self.password}"
 
-        response = await self.execute_http_request(payload,"login")
+        response = await self.execute_http_request(payload, "login")
 
         text = await response.text()
-        _LOGGER.debug("Response: %s",text)
+        _LOGGER.debug("Response: %s", text)
         if text.count("FAILED - User was wrong"):
-            #Response means, that no password is required
+            # Response means, that no password is required
             self.password = ""
             return False
 
@@ -87,19 +87,21 @@ class Client:
             response = await self.execute_http_request(payload)
 
             text = await response.text()
-            _LOGGER.debug("Response to request for user salts: %s",text)
+            _LOGGER.debug("Response to request for user salts: %s", text)
             r_dict: dict[str, Any] = json.loads(text)
 
-            salt: str = r_dict.get('550',{}).get('104')
-            _LOGGER.debug("Salt to hash pwd: %s",salt)
+            salt: str = r_dict.get('550', {}).get('104')
+            _LOGGER.debug("Salt to hash pwd: %s", salt)
 
             try:
                 if salt != 'QUERY IMPOSSIBLE 000' and salt is not None:
-                    hashed_password = bcrypt.hashpw(self.password.encode(), salt.encode())
+                    hashed_password = bcrypt.hashpw(
+                        self.password.encode(), salt.encode())
                     payload = f"u=user&p={hashed_password.decode('utf-8')}"
-                    response = await self.execute_http_request(payload,"login")
+                    response = await self.execute_http_request(payload, "login")
                     text = await response.text()
-                    _LOGGER.debug("Response of login with hashed pwd: %s",text)
+                    _LOGGER.debug(
+                        "Response of login with hashed pwd: %s", text)
                     if text.count("FAILED - Password was wrong"):
                         _LOGGER.debug("Wrong password (hashed)")
                         raise SolarLogAuthenticationError
@@ -107,15 +109,19 @@ class Client:
             except Exception as exception:
                 raise SolarLogAuthenticationError from exception
 
-        self.token = response.cookies["SolarLog"].value
+            self._hashed_pwd = True
 
-        _LOGGER.debug("response: %s",text)
-        _LOGGER.debug("cookies: %s",response.cookies)
-        _LOGGER.debug("Login successful, token: %s",self.token)
+        self.session.cookie_jar.update_cookies(
+            {"SolarLog": response.cookies["SolarLog"].value})
+
+        _LOGGER.debug("response: %s", text)
+        _LOGGER.debug("cookies: %s", response.cookies)
+        _LOGGER.debug("Login successful, token: %s",
+                      response.cookies["SolarLog"].value)
 
         return True
 
-    async def execute_http_request(self, body: str, path: str = "getjp") -> ClientResponse:
+    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()
@@ -124,11 +130,8 @@ class Client:
         url = f"{self.host}/{path}"
 
         header = {"Content-Type": "text/html", "X-SL-CSRF-PROTECTION": "1"}
-        if self.token != "":
-            header |= {"Cookie": f"SolarLog={self.token}"}
-            body = f"token={self.token}; " + body
 
-        _LOGGER.debug("HTTP-request header: %s",header)
+        _LOGGER.debug("HTTP-request header: %s", header)
         _LOGGER.debug("HTTP-request body: %s", body)
 
         try:
@@ -136,7 +139,7 @@ class Client:
                 url=url,
                 headers=header,
                 data=body,
-                timeout=ClientTimeout(total=self.request_timeout),
+                timeout=ClientTimeout(total=timeout or self.request_timeout),
             )
         except asyncio.TimeoutError as exception:
             msg = f"Timeout occurred while connecting to Solar-Log at {self.host}"
@@ -153,14 +156,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()
-        _LOGGER.debug("Parsing http response: %s",text)
+        text = await response.text(errors="replace")
+        _LOGGER.debug("Parsing http response: %s", text)
 
         if text.count('{"QUERY IMPOSSIBLE 000"}'):
             raise SolarLogUpdateError(f"Server response: {text}")
@@ -188,54 +191,56 @@ class Client:
         raw_data = raw_data["801"]["170"]
 
         data = SolarlogData(
-            last_updated = datetime.strptime(raw_data["100"], "%d.%m.%y %H:%M:%S"),
-            power_ac = raw_data["101"],
-            power_dc = raw_data["102"],
-            voltage_ac = raw_data["103"],
-            voltage_dc = raw_data["104"],
-            yield_day = raw_data["105"],
-            yield_yesterday = raw_data["106"],
-            yield_month = raw_data["107"],
-            yield_year = raw_data["108"],
-            yield_total = raw_data["109"],
-            consumption_ac = raw_data["110"],
-            consumption_day = raw_data["111"],
-            consumption_yesterday = raw_data["112"],
-            consumption_month = raw_data["113"],
-            consumption_year = raw_data["114"],
-            consumption_total = raw_data["115"],
-            total_power = raw_data["116"],
+            last_updated=datetime.strptime(
+                raw_data["100"], "%d.%m.%y %H:%M:%S"),
+            power_ac=raw_data["101"],
+            power_dc=raw_data["102"],
+            voltage_ac=raw_data["103"],
+            voltage_dc=raw_data["104"],
+            yield_day=raw_data["105"],
+            yield_yesterday=raw_data["106"],
+            yield_month=raw_data["107"],
+            yield_year=raw_data["108"],
+            yield_total=raw_data["109"],
+            consumption_ac=raw_data["110"],
+            consumption_day=raw_data["111"],
+            consumption_yesterday=raw_data["112"],
+            consumption_month=raw_data["113"],
+            consumption_year=raw_data["114"],
+            consumption_total=raw_data["115"],
+            total_power=raw_data["116"],
         )
 
         return data
 
-    async def get_battery_data(self) -> list[float]:
-        """Get power data from Solar-Log"""
+    async def get_battery_data(self, timeout: float | None = None) -> list[float]:
+        """Get battery data from Solar-Log"""
 
         raw_data: dict = await self.parse_http_response(
-            await self.execute_http_request('{ "858": null }')
+            await self.execute_http_request('{ "858": null }', timeout=timeout)
         )
 
         data: list[float] = raw_data["858"]
 
         return data
 
-    async def get_power_per_inverter(self) -> dict[int, float]:
+    async def get_power_per_inverter(self, timeout: float | None = None) -> dict[int, float]:
         """Get power data from Solar-Log"""
 
         raw_data: dict = await self.parse_http_response(
-            await self.execute_http_request('{ "782": null }')
+            await self.execute_http_request('{ "782": null }', timeout=timeout)
         )
 
-        data = {int(key): val for key, val in raw_data["782"].items() if val != "0"}
+        data = {int(key): val for key,
+                val in raw_data["782"].items() if val != "0"}
 
         return data
 
-    async def get_energy_per_inverter(self) -> dict[int, float]:
+    async def get_energy_per_inverter(self, timeout: float | None = None) -> dict[int, float]:
         """Get power data from Solar-Log"""
 
         raw_data: dict = await self.parse_http_response(
-            await self.execute_http_request('{ "854": null }')
+            await self.execute_http_request('{ "854": null }', timeout=timeout)
         )
         data_list = raw_data["854"][-1][-1]
 
@@ -247,25 +252,27 @@ class Client:
 
         return data
 
-    async def get_energy(self, data: SolarlogData) -> SolarlogData:
+    async def get_energy(self, timeout: float | None = None) -> EnergyData | None:
         """Get energy data from Solar-Log"""
 
         raw_data: dict = await self.parse_http_response(
-            await self.execute_http_request('{ "878": null }')
+            await self.execute_http_request('{ "878": null }', timeout=timeout)
         )
 
         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 EnergyData(
+                production=raw_data["878"][-1][1],
+                self_consumption=raw_data["878"][-1][3]
+            )
 
-        return data
+        return None
 
-    async def get_device_list(self) -> dict[int, str]:
+    async def get_device_list(self, timeout: float | None = None) -> dict[int, str]:
         """Get list of all connected devices."""
 
         # get list of all inverters connected to Solar-Log
         raw_data: dict = await self.parse_http_response(
-            await self.execute_http_request('{ "740": null }')
+            await self.execute_http_request('{ "740": null }', timeout=timeout)
         )
         raw_data = raw_data["740"]
 
@@ -276,7 +283,7 @@ class Client:
                 # get name of the inverter
                 raw_data = await self.parse_http_response(
                     await self.execute_http_request(
-                        f"""{{ "141": {{ "{key}": {{ "119": null }} }} }}"""
+                        f"""{{ "141": {{ "{key}": {{ "119": null }} }} }}""", timeout=timeout
                     )
                 )
                 device_list |= {int(key): raw_data["141"][key]["119"]}

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

@@ -12,7 +12,7 @@ from .solarlog_exceptions import(
     SolarLogConnectionError,
     SolarLogUpdateError,
 )
-from .solarlog_models import BatteryData, InverterData, SolarlogData
+from .solarlog_models import BatteryData, EnergyData, InverterData, SolarlogData
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -82,7 +82,28 @@ class SolarLogConnector:
         return await self.client.login()
 
     async def update_data(self) -> SolarlogData:
-        """Get data from Solar-Log."""
+        """Get all data from Solar-Log."""
+
+        data: SolarlogData = await self.update_basic_data()
+
+        if self.extended_data:
+            energy_data: EnergyData | None = await self.client.get_energy()
+
+            if energy_data is not None:
+                data.production_year = energy_data.production
+                data.self_consumption_year = energy_data.self_consumption
+
+            if self._device_list != {}:
+                data.inverter_data = await self.update_inverter_data()
+
+            data.battery_data = await self.update_battery_data()
+
+            _LOGGER.debug("Extended data updated: %s",data)
+
+        return data
+
+    async def update_basic_data(self) -> SolarlogData:
+        """Get basic data from Solar-Log."""
 
         data: SolarlogData = await self.client.get_basic_data()
 
@@ -94,15 +115,6 @@ class SolarLogConnector:
         data.last_updated = data.last_updated.replace(tzinfo=self.timezone)
 
         _LOGGER.debug("Basic data updated: %s",data)
-        if self.extended_data:
-            data = await self.client.get_energy(data)
-
-            if self._device_list != {}:
-                data.inverter_data = await self.update_inverter_data()
-
-            data.battery_data = await self.update_battery_data()
-
-            _LOGGER.debug("Extended data updated: %s",data)
 
         #calculated values (for downward compatibility)
         data.alternator_loss = data.power_dc - data.power_ac
@@ -119,11 +131,10 @@ class SolarLogConnector:
 
         return data
 
-
-    async def update_battery_data(self) -> BatteryData | None:
+    async def update_battery_data(self, timeout: float | None = None) -> BatteryData | None:
         """Update device specific data."""
 
-        raw_data = await self.client.get_battery_data()
+        raw_data = await self.client.get_battery_data(timeout)
 
         if raw_data == []:
             return None
@@ -139,12 +150,18 @@ class SolarLogConnector:
 
         return battery_data
 
-    async def update_device_list(self) -> dict[int, InverterData]:
+    async def update_energy_data(self, timeout: float | None = None) -> EnergyData | None:
+        """Update energy data (production and self consumption)."""
+
+        return await self.client.get_energy(timeout)
+
+    async def update_device_list(self, timeout: float | None = None) -> dict[int, InverterData]:
         """Update list of devices."""
+
         if not self.extended_data:
             return {}
 
-        devices = await self.client.get_device_list()
+        devices = await self.client.get_device_list(timeout)
 
         self._device_list = {
             key: InverterData(name=value,enabled=self.device(key).enabled)
@@ -154,16 +171,16 @@ class SolarLogConnector:
 
         return self._device_list
 
-    async def update_inverter_data(self) -> dict[int, InverterData]:
+    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()
+        raw_data = await self.client.get_power_per_inverter(timeout)
         for key, value in raw_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()
+        raw_data = await self.client.get_energy_per_inverter(timeout)
         for key, value in raw_data.items():
             if self._device_list.get(key,InverterData).enabled:
                 self._device_list[key].consumption_year = float(value)

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

@@ -13,6 +13,12 @@ class BatteryData():
     level: float = 0
     voltage: float = 0
 
+@dataclass
+class EnergyData():
+    """Energy Data model."""
+
+    production: float | None = None
+    self_consumption: float | None = None
 
 @dataclass
 class InverterData():
@@ -21,7 +27,7 @@ class InverterData():
     name: str = ""
     enabled: bool = False
     current_power: float | None = None
-    consumption_year: float | None= None
+    consumption_year: float | None = None
 
 
 @dataclass

{solarlog_cli-0.6.0 → solarlog_cli-0.7.0}/tests/__snapshots__/test_solarlog_cli.ambr

@@ -87,3 +87,9 @@
     }),
   })
 # ---
+# name: test_update_energy_data[asyncio]
+  dict({
+    'production': 8852462,
+    'self_consumption': 2071,
+  })
+# ---

{solarlog_cli-0.6.0 → solarlog_cli-0.7.0}/tests/test_solarlog_cli.py

@@ -144,7 +144,6 @@ async def test_login_and_data_retreival(responses: aioresponses) -> None:
         "http://solarlog.com", password="pwd")
 
     assert await solarlog_connector.login()
-    assert solarlog_connector.client.token == "token"
 
     responses.post(
         "http://solarlog.com/getjp",
@@ -176,7 +175,6 @@ async def test_login_hashed_pwd(responses: aioresponses) -> None:
         "http://solarlog.com", password="pwd")
 
     assert await solarlog_connector.login()
-    assert solarlog_connector.client.token == "token"
 
     await solarlog_connector.client.close()
     assert solarlog_connector.client.session.closed
@@ -299,6 +297,38 @@ async def test_update_data_without_battery(
     await solarlog_connector.client.close()
     assert solarlog_connector.client.session.closed
 
+async def test_update_energy_data(
+    responses: aioresponses,
+    snapshot: SnapshotAssertion
+) -> None:
+    """Test update energy data."""
+
+    responses.post(
+        "http://solarlog.com/getjp",
+        body=load_fixture("extended_data.json"),
+    )
+    responses.post(
+        "http://solarlog.com/getjp",
+        body='{"878": "QUERY IMPOSSIBLE 000"}',
+    )
+
+    solarlog_connector = SolarLogConnector(
+        "http://solarlog.com",
+        True,
+        "UTC",
+        {0: True, 1: True, 2: False, 3: True},
+    )
+
+    data = await solarlog_connector.update_energy_data()
+
+    assert data == snapshot
+
+    data = await solarlog_connector.update_energy_data()
+
+    assert data is None
+
+    await solarlog_connector.client.close()
+    assert solarlog_connector.client.session.closed
 
 @pytest.mark.parametrize(
     ("status", "request_timeout", "error"),