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

solarlog_cli-0.2.0/.devcontainer/devcontainer.json

@@ -0,0 +1,44 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-in-docker
+{
+	"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",
+
+	"features": {
+		"ghcr.io/devcontainers/features/docker-in-docker:2": {
+			"moby": true,
+			"azureDnsAutoDetection": true,
+			"installDockerBuildx": true,
+			"installDockerComposeSwitch": true,
+			"version": "latest"
+		},
+		"ghcr.io/devcontainers/features/github-cli:1": {
+			"installDirectlyFromGitHubRelease": true,
+			"version": "latest"
+		},
+		"ghcr.io/devcontainers/features/python:1": {
+			"installTools": true,
+			"version": "latest"
+		},
+		"ghcr.io/devcontainers-community/npm-features/prettier:1": {
+			"version": "latest"
+		},
+		"ghcr.io/hspaans/devcontainer-features/pytest:1": {
+			"version": "latest",
+			"plugins": "pytest-testinfra"
+		}
+	}
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "docker --version",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

solarlog_cli-0.2.0/.github/workflows/pylint.yml

@@ -0,0 +1,27 @@
+name: Pylint
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+    steps:
+    - name: ⤵️ Checkout the repository
+      uses: actions/checkout@v4.1.7
+    - name: 🏗 Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5.0.0
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: "pip"
+    - name: 🏗 Install requirement
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+    - name: 🏗 Install pylint
+      run: python3 -m pip install pylint
+    - name: 🚀 Analysing the code with pylint
+      run: |
+        pylint $(git ls-files '*.py')

{solarlog_cli-0.1.6 → solarlog_cli-0.2.0}/.github/workflows/ruff.yml

@@ -13,19 +13,16 @@ jobs:
     name: "Ruff"
     runs-on: "ubuntu-latest"
     steps:
-        - name: "Checkout the repository"
-          uses: "actions/checkout@v4.1.1"
-
-        - name: "Set up Python"
+        - name: ⤵️ Checkout the repository
+          uses: actions/checkout@v4.1.7
+        - name: 🏗 Set up Python
           uses: actions/setup-python@v5.0.0
           with:
             python-version: "3.12"
             cache: "pip"
-
-        - name: "Install requirements"
+        - name: 🏗 Install requirements
           run: python3 -m pip install -r requirements.txt
-
-        - name: "Run"
-          run: |
-            python3 -m pip install ruff
-            python3 -m ruff check ./src/solarlog_cli/*
+        - name: 🏗 Install ruff
+          run: python3 -m pip install ruff
+        - name: 🚀 Run
+          run: python3 -m ruff check ./src/solarlog_cli/*

solarlog_cli-0.2.0/.github/workflows/tests.yml

@@ -0,0 +1,70 @@
+name: Testing
+
+# yamllint disable-line rule:truthy
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+env:
+  DEFAULT_PYTHON: "3.12"
+
+jobs:
+  pytest:
+    name: Python ${{ matrix.python }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.12"]
+    steps:
+      - name: ⤵️ Check out code from GitHub
+        uses: actions/checkout@v4.1.7
+      - name: 🏗 Set up Python ${{ matrix.python }}
+        id: python
+        uses: actions/setup-python@v5.1.1
+        with:
+          python-version: ${{ matrix.python }}
+          cache: "pip"
+      - name: 🏗 Install dependencies
+        run: python3 -m pip install -r requirements.txt
+      - name: 🏗 Install pytest
+        run: python3 -m pip install pytest pytest-cov pytest-aio
+      - name: 🚀 Run pytest
+        run: pytest --cov src tests
+      - name: ⬆️ Upload coverage artifact
+        uses: actions/upload-artifact@v4.3.6
+        with:
+          name: coverage-${{ matrix.python }}
+          path: .coverage
+
+  coverage:
+    runs-on: ubuntu-latest
+    needs: pytest
+    steps:
+      - name: ⤵️ Check out code from GitHub
+        uses: actions/checkout@v4.1.7
+        with:
+          fetch-depth: 0
+      - name: ⬇️ Download coverage data
+        uses: actions/download-artifact@v4.1.8
+      - name: 🏗 Set up Python ${{ env.DEFAULT_PYTHON }}
+        id: python
+        uses: actions/setup-python@v5.1.1
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          cache: "pip"
+      - name: 🏗 Install dependencies
+        run: python3 -m pip install -r requirements.txt
+      - name: 🏗 Install coverage
+        run: python3 -m pip install coverage
+      - name: 🚀 Process coverage results
+        run: |
+          coverage combine coverage*/.coverage*
+          coverage xml -i
+      - name: 🚀 Upload coverage report
+        uses: codecov/codecov-action@v4.5.0
+        with:
+          fail_ci_if_error: true
+          token: ${{ secrets.CODECOV_TOKEN }}

solarlog_cli-0.2.0/.github/workflows/typing.yml

@@ -0,0 +1,33 @@
+name: Typing
+
+# yamllint disable-line rule:truthy
+on:
+    push:
+        branches:
+            - main
+    pull_request:
+        branches:
+            - main
+
+env:
+    DEFAULT_PYTHON: "3.12"
+
+jobs:
+    mypy:
+        name: mypy
+        runs-on: ubuntu-latest
+        steps:
+        - name: ⤵️ Check out code from GitHub
+          uses: actions/checkout@v4.1.7
+        - name: 🏗 Set up Python ${{ env.DEFAULT_PYTHON }}
+          id: python
+          uses: actions/setup-python@v5.1.1
+          with:
+            python-version: ${{ env.DEFAULT_PYTHON }}
+            cache: "pip"
+        - name: 🏗 Install dependencies
+          run: python3 -m pip install -r requirements.txt
+        - name: 🏗 Install mypy
+          run: python3 -m pip install mypy
+        - name: 🚀 Run mypy
+          run: MYPYPATH=src mypy --namespace-packages --explicit-package-bases src tests

solarlog_cli-0.2.0/.gitignore

@@ -0,0 +1,6 @@
+src/solarlog_cli/__pycache__
+tests/__pycache__
+.mypy_cache
+.pytest_cache
+.gitignore
+.venv

solarlog_cli-0.2.0/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "python.analysis.extraPaths": [
+        "./src/solarlog_cli"
+    ],
+    "python.analysis.typeCheckingMode": "basic"
+}

solarlog_cli-0.2.0/.vscode/tasks.json

@@ -0,0 +1,78 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Pytest",
+      "type": "shell",
+      "command": "pytest tests",
+      "dependsOn": ["Install all Requirements"],
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Ruff",
+      "type": "shell",
+      "command": "ruff check src/solarlog_cli tests",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Pylint",
+      "type": "shell",
+      "command": "pylint src tests",
+      "dependsOn": ["Install all Requirements"],
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Code Coverage",
+      "detail": "Generate code coverage report.",
+      "type": "shell",
+      "command": "pytest tests --cov=solarlog_cli --cov-report term-missing --durations-min=1 --durations=0",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Install all Requirements",
+      "type": "shell",
+      "command": "pip install -r requirements.txt",
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "presentation": {
+        "reveal": "always",
+        "panel": "new"
+      },
+      "problemMatcher": []
+    }
+  ]
+}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solarlog_cli
-Version: 0.1.6
+Version: 0.2.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
@@ -15,6 +15,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.12
 Requires-Dist: aiohttp
+Requires-Dist: mashumaro>=3.13
 Description-Content-Type: text/markdown
 
 # Solar-Log-Cli

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

@@ -1,6 +1,6 @@
 [project]
 name = "solarlog_cli"
-version = "0.1.6"
+version = "0.2.0"
 authors = [
   { name="dontinelli", email="73341522+dontinelli@users.noreply.github.com" },
 ]
@@ -9,6 +9,7 @@ readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
   "aiohttp",
+  "mashumaro>=3.13",
 ]
 classifiers = [
     "Programming Language :: Python :: 3",

solarlog_cli-0.2.0/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]  
+pythonpath = src

solarlog_cli-0.2.0/requirements.txt

@@ -0,0 +1,6 @@
+aiohttp>=3.9.5
+aioresponses == 0.7.6
+mashumaro>=3.13
+pytest-aio==1.9.0
+pytest-cov==5.0.0
+syrupy == 4.6.1

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

@@ -5,17 +5,15 @@ from __future__ import annotations
 import asyncio
 from datetime import datetime
 import json
-import logging
 from typing import Any
 
-from aiohttp import ClientSession
+from aiohttp import ClientSession, ClientTimeout
 
 from .solarlog_exceptions import SolarLogConnectionError, SolarLogUpdateError
+from .solarlog_models import SolarlogData
 
 SOLARLOG_REQUEST_PAYLOAD = {801: {170: None}}
 
-_LOGGER = logging.getLogger(__name__)
-
 
 class Client:
     """Client class to access Solar-Log."""
@@ -53,10 +51,12 @@ class Client:
         }
 
         try:
-            async with asyncio.timeout(self.request_timeout):
-                response = await self.session.post(
-                    url=url, headers=header, json=json_payload
-                )
+            response = await self.session.post(
+                url=url,
+                headers=header,
+                json=json_payload,
+                timeout=ClientTimeout(total=self.request_timeout)
+            )
         except asyncio.TimeoutError as exception:
             msg = f"Timeout occurred while connecting to Solar-Log at {self.host}"
             raise SolarLogConnectionError(msg) from exception
@@ -85,31 +85,31 @@ class Client:
 
         return json_response
 
-    async def get_basic_data(self) -> dict[str, int | float | datetime]:
+    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 = raw_data["801"]["170"]
 
-        data = {
-            "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"],
-        }
+        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"],
+        )
 
         return data
 
@@ -128,7 +128,7 @@ class Client:
         raw_data: dict = await self.execute_http_request({854: None})
         data_list = raw_data["854"][-1][-1]
 
-        data = {}
+        data: dict[int, float] = {}
 
         for item in data_list:
             if item != 0:
@@ -136,33 +136,30 @@ class Client:
 
         return data
 
-    async def get_energy(self) -> dict[str, float]:
+    async def get_energy(self, data: SolarlogData) -> SolarlogData:
         """Get power data from Solar-Log"""
 
         raw_data: dict = await self.execute_http_request({878: None})
 
-        data = {
-            "production_year": raw_data["878"][-1][1],
-            # "consumption_year": raw_data["878"][-1][2], # already in basic data
-            "self_consumption_year": raw_data["878"][-1][3],
-        }
+        data.production_year = raw_data["878"][-1][1]
+        data.self_consumption_year = raw_data["878"][-1][3]
 
         return data
 
-    async def get_device_list(self) -> dict[int, dict[str, str]]:
+    async def get_device_list(self) -> dict[int, str]:
         """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 = raw_data["740"]
 
-        device_list: dict[int, dict[str, str]] = {}
+        device_list: dict[int, str] = {}
 
         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}}})
-                device_list |= {int(key): {"name": raw_data["141"][key]["119"]}}
+                device_list |= {int(key): raw_data["141"][key]["119"]}
 
         return device_list
 

solarlog_cli-0.2.0/src/solarlog_cli/solarlog_connector.py

@@ -0,0 +1,142 @@
+"""Connector class to manage access to Solar-Log."""
+
+from datetime import timezone, tzinfo
+import logging
+from zoneinfo import ZoneInfo
+
+from .solarlog_client import Client
+from .solarlog_exceptions import SolarLogUpdateError
+from .solarlog_models import SolarlogData, InverterData
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SolarLogConnector:
+    """Connector class to access Solar-Log."""
+
+    def __init__( # pylint: disable=dangerous-default-value
+        self,
+        host: str,
+        extended_data: bool = False,
+        tz: str = "",
+        device_enabled: dict[int, bool] = {},
+    ):
+        self.client = Client(host)
+        self.extended_data: bool = extended_data
+
+        self._device_list: dict[int, InverterData] = {}
+        if device_enabled != {}:
+            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."""
+
+        return await self.client.test_connection()
+
+    async def update_data(self) -> SolarlogData:
+        """Get data from Solar-Log."""
+
+        data: SolarlogData = await self.client.get_basic_data()
+
+        if data.last_updated.year == 1999:
+            raise SolarLogUpdateError(
+                "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)
+        if self.extended_data:
+            data = await self.client.get_energy(data)
+
+            if self._device_list != {}:
+                data.inverter_data = await self.update_inverter_data()
+
+            _LOGGER.debug("Extended data updated: %s",data)
+
+        #calculated values (for downward compatibility)
+        data.alternator_loss = data.power_dc - data.power_ac
+        if data.power_dc != 0:
+            data.efficiency = data.power_ac / data.power_dc
+        if data.power_ac != 0:
+            data.usage = data.consumption_ac / data.power_ac
+            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 = data.power_dc / data.total_power
+
+        return data
+
+    async def update_device_list(self) -> dict[int, InverterData]:
+        """Update list of devices."""
+        if not self.extended_data or self._device_list is None:
+            return {}
+
+        devices = await self.client.get_device_list()
+
+        self._device_list = {
+            key: InverterData(name=value,enabled=self.device(key).enabled)
+            for key, value in devices.items()
+        }
+        _LOGGER.debug("Device list: %s",self._device_list)
+
+        return self._device_list
+
+    async def update_inverter_data(self) -> dict[int, InverterData]:
+        """Update device specific data."""
+
+        raw_data = await self.client.get_power_per_inverter()
+        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()
+        for key, value in raw_data.items():
+            if self._device_list.get(key,InverterData).enabled:
+                self._device_list[key].consumption_year = float(value)
+
+        _LOGGER.debug("Inverter data updated: %s",self._device_list)
+
+        return self._device_list
+
+    @property
+    def host(self) -> str:
+        """Host of Solar-Log."""
+        return self.client.host
+
+    @property
+    def device_list(self) -> dict[int, InverterData]:
+        """List of all devices of Solar-Log."""
+        return self._device_list
+
+    def device(self, device_id: int) -> InverterData:
+        """Get device data."""
+        return self._device_list.get(device_id, InverterData())
+
+    def device_name(self, device_id: int) -> str:
+        """Get name of Solar-Log attached device."""
+        _LOGGER.debug("Device list: %s; id: %s",self._device_list, device_id)
+
+        return self._device_list.get(device_id, InverterData()).name
+
+    def device_enabled(self, device_id: int | None = None) -> bool | dict[int, bool]:
+        """Get if device is enabled (if id is provided) or list of all devices."""
+        if device_id is None:
+            print("no device_id")
+            print(self._device_list)
+            return {key: value.enabled for key, value in self._device_list.items()}
+        return self._device_list[device_id].enabled
+
+    def set_enabled_devices(self, device_enabled: dict[int, bool]) -> None:
+        """Set enabled devices."""
+        for key, value in device_enabled.items():
+            if self._device_list.get(key) is None:
+                self._device_list |= {key: InverterData(enabled=value)}
+            else:
+                self._device_list[key].enabled = value

solarlog_cli-0.2.0/src/solarlog_cli/solarlog_models.py

@@ -0,0 +1,52 @@
+"""Models for SolarLog."""
+from dataclasses import dataclass
+from datetime import datetime
+
+from mashumaro import DataClassDictMixin
+
+
+@dataclass
+class InverterData():
+    """Inverter Data model."""
+
+    name: str = ""
+    enabled: bool = False
+    current_power: float | None = None
+    consumption_year: float | None = None
+
+
+@dataclass
+class SolarlogData(DataClassDictMixin):
+    """Basic Data model."""
+
+    # pylint: disable=too-many-instance-attributes
+
+    consumption_ac: float
+    consumption_day: float
+    consumption_month: float
+    consumption_total: float
+    consumption_yesterday: float
+    consumption_year: float
+    last_updated: datetime
+    power_ac: float
+    power_dc: float
+    total_power: float
+    voltage_ac: float
+    voltage_dc: float
+    yield_day: float
+    yield_yesterday: float
+    yield_month: float
+    yield_year: float
+    yield_total: float
+
+    #calculated values
+    alternator_loss: float | None = None
+    capacity: float | None = None
+    efficiency: float | None = None
+    power_available: float | None = None
+    usage: float | None = None
+
+    #extended data
+    inverter_data: dict[int, InverterData] | None = None
+    production_year: float | None = None
+    self_consumption_year: float | None = None