qilowatt 2024.2.1__tar.gz

qilowatt-2024.2.1/.github/workflows/publish.yml

@@ -0,0 +1,39 @@
+name: Build and Publish Package
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'  # Triggers on version tags like v1.0.0
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      contents: read  # For actions/checkout
+      packages: write  # For publishing to PyPI
+      id-token: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.9'  # Use the Python version compatible with your package
+
+      - name: Install build tools
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine setuptools_scm
+
+      - name: Build package
+        run: |
+          python -m build --sdist --wheel
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Confirm success
+        run: echo "Package published successfully!"

qilowatt-2024.2.1/.gitignore

@@ -0,0 +1 @@
+.DS_Store

qilowatt-2024.2.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 YOUR NAME
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qilowatt-2024.2.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.2
+Name: qilowatt
+Version: 2024.2.1
+Summary: Communication package for Qilowatt inverters
+Author-email: Tanel Vakker <tanel@vakker.org>
+License: MIT
+Project-URL: Homepage, https://github.com/qilowatt/qilowatt-py
+Project-URL: Documentation, https://github.com/qilowatt/qilowatt-py#readme
+Project-URL: Issues, https://github.com/qilowatt/qilowatt-py/issues
+Project-URL: Repository, https://github.com/qilowatt/qilowatt-py
+Keywords: mqtt,qilowatt,inverter,energy,home-assistant
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: paho-mqtt>=1.6.1
+Requires-Dist: getmac>=0.8.3
+
+# [qilowatt](<https://qilowatt.eu>) Python Module
+
+
+  - connecting to qilowatt MQTT server to send status, state and state0.
+  - Receives BACKLOG commands
+  - see example.py for usage

qilowatt-2024.2.1/README.md

@@ -0,0 +1,6 @@
+# [qilowatt](<https://qilowatt.eu>) Python Module
+
+
+  - connecting to qilowatt MQTT server to send status, state and state0.
+  - Receives BACKLOG commands
+  - see example.py for usage

qilowatt-2024.2.1/example.py

@@ -0,0 +1,79 @@
+# example.py
+
+import logging
+from qilowatt import QilowattMQTTClient, EnergyData, MetricsData
+import time
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+
+# User-provided MQTT credentials and inverter ID
+mqtt_username = 'your_username'
+mqtt_password = 'your_password'
+inverter_id = 'your_inverter_id'
+
+# Create the Qilowatt MQTT client
+client = QilowattMQTTClient(
+    mqtt_username=mqtt_username,
+    mqtt_password=mqtt_password,
+    inverter_id=inverter_id,
+    host='test-mqtt.qilowatt.it',
+    port=8883,
+    tls=True
+)
+def on_command_received(command):
+    print(f"Received WorkMode Command: {command}")
+
+# Set the command callback
+client.set_command_callback(on_command_received)
+
+# Connect to the MQTT broker
+client.connect()
+
+# Wait a moment to ensure connection is established
+time.sleep(2)
+
+# Prepare ENERGY and METRICS data
+energy_data = EnergyData(
+    Power=[100.0, 100.0, 100.0],
+    Today=5.0,
+    Total=1000.0,
+    Current=[5.0, 5.0, 5.0],
+    Voltage=[230.0, 230.0, 230.0],
+    Frequency=50.0
+)
+
+metrics_data = MetricsData(
+    PvPower=[200.0, 200.0],
+    PvVoltage=[300.0, 300.0],
+    PvCurrent=[8.0, 8.0],
+    LoadPower=[500.0, 500.0, 500.0],
+    BatterySOC=80,
+    LoadCurrent=[10.0, 10.0, 10.0],
+    BatteryPower=[400.0],
+    BatteryCurrent=[15.0],
+    BatteryVoltage=[48.0],
+    GridExportLimit=5000.0,
+    BatteryTemperature=[30.0],
+    InverterTemperature=40.0
+)
+
+# Set the data
+client.set_energy_data(energy_data)
+client.set_metrics_data(metrics_data)
+
+# Now the module will automatically start sending data at the specified intervals
+
+# Keep the script running to receive commands and send data
+try:
+    print("Running. Press Ctrl+C to exit.")
+    while True:
+        # Simulate updating data periodically
+        time.sleep(30)
+        # Update ENERGY data if needed
+        energy_data.Today += 0.1
+        client.set_energy_data(energy_data)
+except KeyboardInterrupt:
+    print("Exiting...")
+finally:
+    client.disconnect()

qilowatt-2024.2.1/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel", "setuptools_scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qilowatt"
+dynamic = ["version"]
+description = "Communication package for Qilowatt inverters"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { text = "MIT" }
+authors = [
+    { name = "Tanel Vakker", email = "tanel@vakker.org" }
+]
+keywords = ["mqtt", "qilowatt", "inverter", "energy", "home-assistant"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Home Automation",
+    "Topic :: Software Development :: Libraries",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Operating System :: OS Independent",
+]
+
+dependencies = [
+    "paho-mqtt>=1.6.1",
+    "getmac>=0.8.3",
+]
+
+[project.urls]
+Homepage = "https://github.com/qilowatt/qilowatt-py"
+Documentation = "https://github.com/qilowatt/qilowatt-py#readme"
+Issues = "https://github.com/qilowatt/qilowatt-py/issues"
+Repository = "https://github.com/qilowatt/qilowatt-py"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools_scm]
+version_scheme = "post-release"
+local_scheme = "no-local-version"

qilowatt-2024.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qilowatt-2024.2.1/src/qilowatt/__init__.py

@@ -0,0 +1,36 @@
+# qilowatt/__init__.py
+
+from .client import QilowattMQTTClient
+from .models import (
+    EnergyData, MetricsData, WorkModeCommand,
+    Status0Data, StatusData, StatusPRMData, StatusFWRData,
+    StatusLOGData, StatusNETData, StatusMQTData, StatusTIMData
+)
+from .exceptions import (
+    QilowattException,
+    ConnectionError,
+    AuthenticationError,
+)
+
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "unknown"
+
+__all__ = [
+    "QilowattMQTTClient",
+    "EnergyData",
+    "MetricsData",
+    "WorkModeCommand",
+    "Status0Data",
+    "StatusData",
+    "StatusPRMData",
+    "StatusFWRData",
+    "StatusLOGData",
+    "StatusNETData",
+    "StatusMQTData",
+    "StatusTIMData",
+    "QilowattException",
+    "ConnectionError",
+    "AuthenticationError",
+]

qilowatt-2024.2.1/src/qilowatt/client.py

@@ -0,0 +1,373 @@
+# qilowatt/client.py
+
+import ssl
+import json
+import threading
+import logging
+import paho.mqtt.client as mqtt
+from typing import Callable, Optional
+from .models import SensorData, WorkModeCommand, EnergyData, MetricsData, Status0Data, StatusData, StatusPRMData, StatusFWRData, StatusLOGData, StatusNETData, StatusMQTData, StatusTIMData
+from .exceptions import ConnectionError, AuthenticationError
+from datetime import datetime, timezone
+import platform
+import socket
+import getmac
+
+_logger = logging.getLogger(__name__)
+
+class QilowattMQTTClient:
+    """Client to handle MQTT communication with Qilowatt server."""
+
+    def __init__(
+        self,
+        mqtt_username: str,
+        mqtt_password: str,
+        inverter_id: str,
+        host: str = "mqtt.qilowatt.it",
+        port: int = 8883,
+        tls: bool = True,
+    ):
+        self.mqtt_username = mqtt_username
+        self.mqtt_password = mqtt_password
+        self.inverter_id = inverter_id
+
+        self.host = host
+        self.port = port
+        self.tls = tls
+
+        self._client = mqtt.Client()
+        self._connected = False
+        self._lock = threading.Lock()
+
+        self._sensor_topic = f"Q/{self.inverter_id}/SENSOR"
+        self._state_topic = f"Q/{self.inverter_id}/STATE"
+        self._status0_topic = f"Q/{self.inverter_id}/STATUS0"
+        self._command_topic = f"Q/{self.inverter_id}/cmnd/backlog"
+
+        self._workmode_command: Optional[WorkModeCommand] = None  # Store the latest command
+        self._workmode_command = WorkModeCommand.from_dict({"Mode": "normal"})  # Default to normal mode
+
+        self._on_command_callback: Optional[Callable[[WorkModeCommand], None]] = None
+
+        # Data storage
+        self._energy_data: Optional[EnergyData] = None
+        self._metrics_data: Optional[MetricsData] = None
+
+        # Timers
+        self._sensor_timer_thread: Optional[threading.Thread] = None
+        self._state_timer_thread: Optional[threading.Thread] = None
+        self._status0_timer_thread: Optional[threading.Thread] = None
+
+        self._sensor_timer_stop_event = threading.Event()
+        self._state_timer_stop_event = threading.Event()
+        self._status0_timer_stop_event = threading.Event()
+
+        # Flags to indicate whether data has been initialized
+        self._data_initialized = False
+
+        # Initialize startup time and boot count
+        self._startup_utc = datetime.utcnow()
+        self._boot_count = 1  # Increment as appropriate
+
+        self._setup_client()
+
+    def _setup_client(self):
+        if self.tls:
+            self._client.tls_set(cert_reqs=ssl.CERT_NONE)
+            self._client.tls_insecure_set(True)
+
+        self._client.username_pw_set(self.mqtt_username, self.mqtt_password)
+        self._client.on_connect = self._on_connect
+        self._client.on_message = self._on_message
+        self._client.on_disconnect = self._on_disconnect
+
+    def _on_connect(self, client, userdata, flags, rc):
+        _logger.debug(f"Connected with result code {rc}")
+        if rc == 0:
+            self._connected = True
+            # Subscribe to command topic
+            client.subscribe(self._command_topic)
+        elif rc == 5:
+            raise AuthenticationError("Authentication failed")
+        else:
+            raise ConnectionError(f"Connection failed with result code {rc}")
+
+    def _on_disconnect(self, client, userdata, rc):
+        _logger.debug(f"Disconnected with result code {rc}")
+        self._connected = False
+
+    def _on_message(self, client, userdata, msg):
+        _logger.debug(f"Message received on {msg.topic}: {msg.payload}")
+        if msg.topic == self._command_topic:
+            self._handle_command_message(msg.payload)
+
+    def _handle_command_message(self, payload):
+        try:
+            message = payload.decode('utf-8')
+            if message.startswith("WORKMODE"):
+                json_part = message[len("WORKMODE "):]
+                data = json.loads(json_part)
+                command = WorkModeCommand.from_dict(data)
+                self._workmode_command = command  # Store internally
+                if self._on_command_callback:
+                    self._on_command_callback(command)
+        except Exception as e:
+            _logger.error(f"Error processing command message: {e}")
+
+    def set_command_callback(self, callback: Callable[[WorkModeCommand], None]):
+        """Set the callback function to be called when a command is received."""
+        self._on_command_callback = callback
+
+    def set_energy_data(self, energy_data: EnergyData):
+        """Set the ENERGY data."""
+        self._energy_data = energy_data
+        self._check_data_initialized()
+
+    def set_metrics_data(self, metrics_data: MetricsData):
+        """Set the METRICS data."""
+        self._metrics_data = metrics_data
+        self._check_data_initialized()
+
+    def _check_data_initialized(self):
+        if self._energy_data and self._metrics_data and not self._data_initialized:
+            self._data_initialized = True
+            self._start_timers()
+
+    def _start_timers(self):
+        # Start the timers for sending data
+        self._start_sensor_timer()
+        self._start_state_timer()
+        self._start_status0_timer()
+
+    def _start_sensor_timer(self):
+        def sensor_timer():
+            while not self._sensor_timer_stop_event.wait(10):
+                self.publish_sensor_data()
+
+        self._sensor_timer_thread = threading.Thread(target=sensor_timer, name="SensorTimer")
+        self._sensor_timer_thread.daemon = True
+        self._sensor_timer_thread.start()
+        _logger.debug("Started sensor data timer.")
+
+    def _start_state_timer(self):
+        def state_timer():
+            while not self._state_timer_stop_event.wait(60):
+                self.publish_state_data()
+
+        self._state_timer_thread = threading.Thread(target=state_timer, name="StateTimer")
+        self._state_timer_thread.daemon = True
+        self._state_timer_thread.start()
+        _logger.debug("Started state data timer.")
+
+    def _start_status0_timer(self):
+        def status0_timer():
+            # Send at startup
+            self.publish_status0_data()
+            # Then every 60 minutes
+            while not self._status0_timer_stop_event.wait(3600):
+                self.publish_status0_data()
+
+        self._status0_timer_thread = threading.Thread(target=status0_timer, name="Status0Timer")
+        self._status0_timer_thread.daemon = True
+        self._status0_timer_thread.start()
+        _logger.debug("Started STATUS0 data timer.")
+
+    def publish_sensor_data(self):
+        """Publish sensor data to the MQTT broker."""
+        if self._connected and self._data_initialized:
+            # Build the sensor data
+            sensor_data = SensorData(
+                ENERGY=self._energy_data,
+                METRICS=self._metrics_data,
+                WORKMODE=self._workmode_command  # Use the latest WORKMODE command
+            )
+            # Update the time
+            sensor_data.Time = datetime.utcnow().isoformat()
+            payload = json.dumps(sensor_data.to_dict())
+            self._client.publish(self._sensor_topic, payload)
+            _logger.debug(f"Published sensor data to {self._sensor_topic}")
+        else:
+            _logger.warning("Cannot publish sensor data: not connected or data not initialized.")
+
+    def publish_state_data(self):
+        """Publish state data to the MQTT broker."""
+        if self._connected:
+            state_data = self.generate_state_data()
+            payload = json.dumps(state_data)
+            self._client.publish(self._state_topic, payload)
+            _logger.debug(f"Published state data to {self._state_topic}")
+        else:
+            _logger.warning("Cannot publish state data: not connected.")
+
+    def generate_state_data(self):
+        """Generate the STATE data."""
+        state_data = {
+            "Time": datetime.utcnow().isoformat(),
+            # Add other state fields as necessary
+            # For example:
+            "Uptime": int((datetime.utcnow() - self._startup_utc).total_seconds()),
+            "POWER1": "ON",
+        }
+        return state_data
+
+    def publish_status0_data(self):
+        """Publish STATUS0 data to the MQTT broker."""
+        if self._connected:
+            status0_data = self.generate_status0_data()
+            payload = json.dumps(status0_data.to_dict())
+            self._client.publish(self._status0_topic, payload)
+            _logger.debug(f"Published STATUS0 data to {self._status0_topic}")
+        else:
+            _logger.warning("Cannot publish STATUS0 data: not connected.")
+
+    def generate_status0_data(self) -> Status0Data:
+        """Generate the STATUS0 data."""
+        # Automatically determine some values
+        device_name = "Qilowatt Device"
+        friendly_name = ["Home Assistant", "", ""]
+        topic = self.inverter_id  # Assuming inverter_id is unique
+
+        startup_utc = self._startup_utc.replace(tzinfo=timezone.utc).isoformat()
+        boot_count = self._boot_count
+
+        version = "QW-MQTT-API-24.10.01"  # Example version
+        hardware = platform.machine()
+
+        tele_period = 10  # Example telemetry period
+
+        hostname = socket.gethostname()
+        ip_address = self._get_ip_address()
+        gateway = self._get_default_gateway()
+        subnet_mask = self._get_subnet_mask()
+        mac_address = getmac.get_mac_address()
+
+        mqtt_host = self.host
+        mqtt_port = self.port
+        mqtt_client = self._client._client_id.decode('utf-8') if self._client._client_id else ''
+        mqtt_user = self.mqtt_username
+
+        utc_now = datetime.utcnow().replace(tzinfo=timezone.utc).isoformat()
+        local_now = datetime.now().isoformat()
+
+        status = StatusData(
+            DeviceName=device_name,
+            FriendlyName=friendly_name,
+            Topic=topic,
+        )
+
+        status_prm = StatusPRMData(
+            StartupUTC=startup_utc,
+            BootCount=boot_count,
+        )
+
+        status_fwr = StatusFWRData(
+            Version=version,
+            Hardware=hardware,
+        )
+
+        status_log = StatusLOGData(
+            TelePeriod=tele_period,
+        )
+
+        status_net = StatusNETData(
+            Hostname=hostname,
+            IPAddress=ip_address,
+            Gateway=gateway,
+            Subnetmask=subnet_mask,
+            Mac=mac_address,
+        )
+
+        mqtt_client_mask = "QWAPI_%06X"  # Example mask
+
+        status_mqt = StatusMQTData(
+            MqttHost=mqtt_host,
+            MqttPort=mqtt_port,
+            MqttClient=mqtt_client,
+            MqttUser=mqtt_user,
+            MqttClientMask=mqtt_client_mask,
+        )
+
+        status_tim = StatusTIMData(
+            UTC=utc_now,
+            Local=local_now,
+        )
+
+        status0_data = Status0Data(
+            Status=status,
+            StatusPRM=status_prm,
+            StatusFWR=status_fwr,
+            StatusLOG=status_log,
+            StatusNET=status_net,
+            StatusMQT=status_mqt,
+            StatusTIM=status_tim,
+        )
+
+        return status0_data
+
+    # Helper methods to retrieve network information
+    def _get_ip_address(self):
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            # This IP is not used; it's just to get the appropriate interface
+            s.connect(("8.8.8.8", 80))
+            ip_address = s.getsockname()[0]
+            s.close()
+            return ip_address
+        except Exception as e:
+            _logger.error(f"Error getting IP address: {e}")
+            return "0.0.0.0"
+
+    def _get_default_gateway(self):
+        # Implement logic to retrieve default gateway
+        # Placeholder implementation
+        return "192.168.1.1"
+
+    def _get_subnet_mask(self):
+        # Implement logic to retrieve subnet mask
+        # Placeholder implementation
+        return "255.255.255.0"
+
+    def connect(self):
+        """Connect to the MQTT broker and start the loop."""
+        with self._lock:
+            if not self._connected:
+                self._client.connect(self.host, self.port)
+                self._client.loop_start()
+
+    def disconnect(self):
+        """Disconnect from the MQTT broker and stop the loop."""
+        with self._lock:
+            if self._connected:
+                self._client.loop_stop()
+                self._client.disconnect()
+                self._connected = False
+        self._stop_timers()
+
+    def _stop_timers(self):
+        """Stop all running timers."""
+        if self._sensor_timer_thread:
+            self._sensor_timer_stop_event.set()
+            self._sensor_timer_thread.join()
+            _logger.debug("Stopped sensor data timer.")
+
+        if self._state_timer_thread:
+            self._state_timer_stop_event.set()
+            self._state_timer_thread.join()
+            _logger.debug("Stopped state data timer.")
+
+        if self._status0_timer_thread:
+            self._status0_timer_stop_event.set()
+            self._status0_timer_thread.join()
+            _logger.debug("Stopped STATUS0 data timer.")
+
+        # Reset events and threads
+        self._sensor_timer_stop_event.clear()
+        self._state_timer_stop_event.clear()
+        self._status0_timer_stop_event.clear()
+        self._sensor_timer_thread = None
+        self._state_timer_thread = None
+        self._status0_timer_thread = None
+
+    def get_workmode_command(self) -> Optional[WorkModeCommand]:
+        """Get the latest WORKMODE command received."""
+        return self._workmode_command

qilowatt-2024.2.1/src/qilowatt/constants.py

@@ -0,0 +1 @@
+QILOWATT_VERSION = "1.0.0"

qilowatt-2024.2.1/src/qilowatt/exceptions.py

@@ -0,0 +1,15 @@
+class QilowattException(Exception):
+    """Base exception for Qilowatt errors."""
+    pass
+
+class ConnectionError(QilowattException):
+    """Raised when there is a connection error."""
+    pass
+
+class AuthenticationError(QilowattException):
+    """Raised when authentication fails."""
+    pass
+
+class DataValidationError(QilowattException):
+    """Raised when data validation fails."""
+    pass

qilowatt-2024.2.1/src/qilowatt/models.py

@@ -0,0 +1,165 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+from datetime import datetime
+import uuid
+
+@dataclass
+class PingData:
+    Reachable: bool = True
+
+@dataclass
+class ESP32Data:
+    Temperature: float = 64.4  # Default value
+
+@dataclass
+class EnergyData:
+    Power: List[float]
+    Today: float
+    Total: float
+    Current: List[float]
+    Voltage: List[float]
+    Frequency: float
+
+@dataclass
+class MetricsData:
+    PvPower: List[float]
+    PvVoltage: List[float]
+    PvCurrent: List[float]
+    LoadPower: List[float]
+    BatterySOC: int
+    LoadCurrent: List[float]
+    BatteryPower: List[float]
+    BatteryCurrent: List[float]
+    BatteryVoltage: List[float]
+    GridExportLimit: float
+    BatteryTemperature: List[float]
+    InverterTemperature: float
+    AlarmCodes: List[int] = field(default_factory=lambda: [0, 0, 0, 0, 0, 0])
+    InverterStatus: int = 2  # Default value
+
+@dataclass
+class VersionData:
+    fs: str = "24.7.1"
+    led: str = "24.3.1"
+    inverter: str = "24.10.2"
+    qilowatt: str = "24.8.1"
+    registers: float = 2.5
+
+@dataclass
+class WorkModeCommand:
+    Mode: str = "normal"
+    _source: Optional[str] = None
+    BatterySoc: Optional[int] = None
+    PowerLimit: Optional[int] = None
+    PeakShaving: Optional[int] = None
+    ChargeCurrent: Optional[int] = None
+    DischargeCurrent: Optional[int] = None
+    MaxPower: Optional[int] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'WorkModeCommand':
+        return cls(
+            Mode=data.get("Mode"),
+            _source=data.get("_source"),
+            BatterySoc=data.get("BatterySoc"),
+            PowerLimit=data.get("PowerLimit"),
+            PeakShaving=data.get("PeakShaving"),
+            ChargeCurrent=data.get("ChargeCurrent"),
+            DischargeCurrent=data.get("DischargeCurrent"),
+            MaxPower=data.get("MaxPower"),
+        )
+
+@dataclass
+class SensorData:
+    ENERGY: EnergyData
+    METRICS: MetricsData
+    PING: PingData = field(default_factory=PingData)
+    Time: str = field(default_factory=lambda: datetime.utcnow().isoformat())
+    ESP32: ESP32Data = field(default_factory=ESP32Data)
+    VERSION: VersionData = field(default_factory=VersionData)
+    TempUnit: str = "C"
+    POWER1: int = 1
+    WORKMODE: Optional[WorkModeCommand] = None  # Will be set internally
+
+    def to_dict(self) -> dict:
+        """Convert the dataclass to a dictionary."""
+        data = {
+            "PING": self.PING.__dict__,
+            "Time": self.Time,
+            "ESP32": self.ESP32.__dict__,
+            "ENERGY": self.ENERGY.__dict__,
+            "METRICS": self.METRICS.__dict__,
+            "VERSION": self.VERSION.__dict__,
+            "TempUnit": self.TempUnit,
+            "POWER1": self.POWER1,
+            "WORKMODE": self.WORKMODE.__dict__ if self.WORKMODE else {},
+        }
+        return data
+
+@dataclass
+class StatusData:
+    DeviceName: str
+    FriendlyName: List[str]
+    Topic: str
+
+@dataclass
+class StatusPRMData:
+    StartupUTC: str
+    BootCount: int
+
+@dataclass
+class StatusFWRData:
+    Version: str
+    Hardware: str
+
+@dataclass
+class StatusLOGData:
+    TelePeriod: int
+
+@dataclass
+class StatusNETData:
+    Hostname: str
+    IPAddress: str
+    Gateway: str
+    Subnetmask: str
+    Mac: str
+    DNSServer1: Optional[str] = None
+    DNSServer2: Optional[str] = None
+
+@dataclass
+class StatusMQTData:
+    MqttHost: str
+    MqttPort: int
+    MqttClient: str
+    MqttUser: str
+    MqttCount: Optional[int] = None
+    MqttClientMask: Optional[str] = None
+
+@dataclass
+class StatusTIMData:
+    UTC: str
+    Local: str
+    StartDST: Optional[str] = None
+    EndDST: Optional[str] = None
+    Timezone: Optional[int] = None
+
+@dataclass
+class Status0Data:
+    Status: StatusData
+    StatusPRM: StatusPRMData
+    StatusFWR: StatusFWRData
+    StatusLOG: StatusLOGData
+    StatusNET: StatusNETData
+    StatusMQT: StatusMQTData
+    StatusTIM: StatusTIMData
+
+    def to_dict(self) -> dict:
+        return {
+            "Status": self.Status.__dict__,
+            "StatusPRM": self.StatusPRM.__dict__,
+            "StatusFWR": self.StatusFWR.__dict__,
+            "StatusLOG": self.StatusLOG.__dict__,
+            "StatusNET": self.StatusNET.__dict__,
+            "StatusMQT": self.StatusMQT.__dict__,
+            "StatusTIM": self.StatusTIM.__dict__,
+        }

qilowatt-2024.2.1/src/qilowatt.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.2
+Name: qilowatt
+Version: 2024.2.1
+Summary: Communication package for Qilowatt inverters
+Author-email: Tanel Vakker <tanel@vakker.org>
+License: MIT
+Project-URL: Homepage, https://github.com/qilowatt/qilowatt-py
+Project-URL: Documentation, https://github.com/qilowatt/qilowatt-py#readme
+Project-URL: Issues, https://github.com/qilowatt/qilowatt-py/issues
+Project-URL: Repository, https://github.com/qilowatt/qilowatt-py
+Keywords: mqtt,qilowatt,inverter,energy,home-assistant
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: paho-mqtt>=1.6.1
+Requires-Dist: getmac>=0.8.3
+
+# [qilowatt](<https://qilowatt.eu>) Python Module
+
+
+  - connecting to qilowatt MQTT server to send status, state and state0.
+  - Receives BACKLOG commands
+  - see example.py for usage

qilowatt-2024.2.1/src/qilowatt.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+.gitignore
+LICENSE.txt
+README.md
+example.py
+pyproject.toml
+.github/workflows/publish.yml
+src/qilowatt/__init__.py
+src/qilowatt/client.py
+src/qilowatt/constants.py
+src/qilowatt/exceptions.py
+src/qilowatt/models.py
+src/qilowatt.egg-info/PKG-INFO
+src/qilowatt.egg-info/SOURCES.txt
+src/qilowatt.egg-info/dependency_links.txt
+src/qilowatt.egg-info/requires.txt
+src/qilowatt.egg-info/top_level.txt

qilowatt-2024.2.1/src/qilowatt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qilowatt-2024.2.1/src/qilowatt.egg-info/requires.txt

@@ -0,0 +1,2 @@
+paho-mqtt>=1.6.1
+getmac>=0.8.3

qilowatt-2024.2.1/src/qilowatt.egg-info/top_level.txt

@@ -0,0 +1 @@
+qilowatt