goodwe 0.4.8__py3-none-any.whl → 0.4.9__py3-none-any.whl

goodwe/protocol.py

@@ -1,3 +1,4 @@
+"""Low level IP communication protocol implementation."""
 from __future__ import annotations
 
 import asyncio
@@ -6,7 +7,7 @@ import logging
 import platform
 import socket
 from asyncio.futures import Future
-from typing import Tuple, Optional, Callable
+from typing import Optional, Callable
 
 from .exceptions import MaxRetriesException, PartialResponseException, RequestFailedException, RequestRejectedException
 from .modbus import create_modbus_rtu_request, create_modbus_rtu_multi_request, create_modbus_tcp_request, \
@@ -55,12 +56,11 @@ class InverterProtocol:
         """
         if self._lock and self._running_loop == asyncio.get_event_loop():
             return self._lock
-        else:
-            logger.debug("Creating lock instance for current event loop.")
-            self._lock = asyncio.Lock()
-            self._running_loop = asyncio.get_event_loop()
-            self._close_transport()
-            return self._lock
+        logger.debug("Creating lock instance for current event loop.")
+        self._lock = asyncio.Lock()
+        self._running_loop = asyncio.get_event_loop()
+        self._close_transport()
+        return self._lock
 
     def _max_retries_reached(self) -> Future:
         logger.debug("Max number of retries (%d) reached, request %s failed.", self.retries, self.command)
@@ -121,9 +121,11 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
 
     async def _connect(self) -> None:
         if not self._transport or self._transport.is_closing():
+            allow_broadcast = platform.system() == "Darwin" and self._host == "255.255.255.255"
             self._transport, self.protocol = await asyncio.get_running_loop().create_datagram_endpoint(
                 lambda: self,
                 remote_addr=(self._host, self._port),
+                allow_broadcast=allow_broadcast,
             )
 
     def connection_made(self, transport: asyncio.DatagramTransport) -> None:
@@ -138,7 +140,7 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
             logger.debug("Socket closed.")
         self._close_transport()
 
-    def datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None:
+    def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
         """On datagram received"""
         if self._timer:
             self._timer.cancel()
@@ -192,8 +194,7 @@ class UdpInverterProtocol(InverterProtocol, asyncio.DatagramProtocol):
                 if not self.keep_alive:
                     self._close_transport()
                 return await self.send_request(command)
-            else:
-                return self._max_retries_reached()
+            return self._max_retries_reached()
         finally:
             if self._lock and self._lock.locked():
                 self._lock.release()
@@ -271,7 +272,6 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
     def connection_made(self, transport: asyncio.DatagramTransport) -> None:
         """On connection made"""
         logger.debug("Connection opened.")
-        pass
 
     def eof_received(self) -> None:
         logger.debug("EOF received.")
@@ -340,8 +340,7 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
                     self._lock.release()
                 self._close_transport()
                 return await self.send_request(command)
-            else:
-                return self._max_retries_reached()
+            return self._max_retries_reached()
         except (ConnectionRefusedError, TimeoutError, OSError, asyncio.TimeoutError):
             if self._retry < self.retries:
                 logger.debug("Connection refused error.")
@@ -349,8 +348,7 @@ class TcpInverterProtocol(InverterProtocol, asyncio.Protocol):
                 if self._lock and self._lock.locked():
                     self._lock.release()
                 return await self.send_request(command)
-            else:
-                return self._max_retries_reached()
+            return self._max_retries_reached()
         finally:
             if self._lock and self._lock.locked():
                 self._lock.release()
@@ -402,8 +400,7 @@ class ProtocolResponse:
     def response_data(self) -> bytes:
         if self.command is not None:
             return self.command.trim_response(self.raw_data)
-        else:
-            return self.raw_data
+        return self.raw_data
 
     def seek(self, address: int) -> None:
         if self.command is not None:
@@ -457,10 +454,9 @@ class ProtocolCommand:
             result = response_future.result()
             if result is not None:
                 return ProtocolResponse(result, self)
-            else:
-                raise RequestFailedException(
-                    "No response received to '" + self.request.hex() + "' request."
-                )
+            raise RequestFailedException(
+                "No response received to '" + self.request.hex() + "' request."
+            )
         except (asyncio.CancelledError, ConnectionRefusedError):
             raise RequestFailedException(
                 "No valid response received to '" + self.request.hex() + "' request."
@@ -543,12 +539,11 @@ class Aa55ProtocolCommand(ProtocolCommand):
         if self.request[4] == 1:
             if self.request[5] == 2:
                 return f'READ device info ({self.request.hex()})'
-            elif self.request[5] == 6:
+            if self.request[5] == 6:
                 return f'READ runtime data ({self.request.hex()})'
-            elif self.request[5] == 9:
+            if self.request[5] == 9:
                 return f'READ settings ({self.request.hex()})'
-        else:
-            return self.request.hex()
+        return self.request.hex()
 
 
 class Aa55ReadCommand(Aa55ProtocolCommand):
@@ -557,13 +552,12 @@ class Aa55ReadCommand(Aa55ProtocolCommand):
     """
 
     def __init__(self, offset: int, count: int):
-        super().__init__("011A03" + "{:04x}".format(offset) + "{:02x}".format(count), "019A", offset, count)
+        super().__init__(f"011A03{offset:04x}{count:02x}", "019A", offset, count)
 
     def __repr__(self):
         if self.value > 1:
             return f'READ {self.value} registers from {self.first_address} ({self.request.hex()})'
-        else:
-            return f'READ register {self.first_address} ({self.request.hex()})'
+        return f'READ register {self.first_address} ({self.request.hex()})'
 
 
 class Aa55WriteCommand(Aa55ProtocolCommand):
@@ -572,7 +566,7 @@ class Aa55WriteCommand(Aa55ProtocolCommand):
     """
 
     def __init__(self, register: int, value: int):
-        super().__init__("023905" + "{:04x}".format(register) + "01" + "{:04x}".format(value), "02B9", register, value)
+        super().__init__(f"023905{register:04x}01{value:04x}", "02B9", register, value)
 
     def __repr__(self):
         return f'WRITE {self.value} to register {self.first_address} ({self.request.hex()})'
@@ -584,7 +578,7 @@ class Aa55WriteMultiCommand(Aa55ProtocolCommand):
     """
 
     def __init__(self, offset: int, values: bytes):
-        super().__init__("02390B" + "{:04x}".format(offset) + "{:02x}".format(len(values)) + values.hex(),
+        super().__init__(f"02390B{offset:04x}{len(values):02x}{values.hex()}",
                          "02B9", offset, len(values) // 2)
 
 
@@ -640,8 +634,7 @@ class ModbusRtuReadCommand(ModbusRtuProtocolCommand):
     def __repr__(self):
         if self.value > 1:
             return f'READ {self.value} registers from {self.first_address} ({self.request.hex()})'
-        else:
-            return f'READ register {self.first_address} ({self.request.hex()})'
+        return f'READ register {self.first_address} ({self.request.hex()})'
 
 
 class ModbusRtuWriteCommand(ModbusRtuProtocolCommand):
@@ -710,8 +703,7 @@ class ModbusTcpReadCommand(ModbusTcpProtocolCommand):
     def __repr__(self):
         if self.value > 1:
             return f'READ {self.value} registers from {self.first_address} ({self.request.hex()})'
-        else:
-            return f'READ register {self.first_address} ({self.request.hex()})'
+        return f'READ register {self.first_address} ({self.request.hex()})'
 
 
 class ModbusTcpWriteCommand(ModbusTcpProtocolCommand):

goodwe/sensor.py

@@ -1,3 +1,4 @@
+"""Inverter sensor types."""
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
@@ -6,7 +7,6 @@ from enum import IntEnum
 from struct import unpack
 from typing import Any, Callable, Optional
 
-from .const import *
 from .inverter import Sensor, SensorKind
 from .protocol import ProtocolResponse
 
@@ -15,13 +15,13 @@ MONTH_NAMES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "O
 
 
 class ScheduleType(IntEnum):
-    ECO_MODE = 0,
-    DRY_CONTACT_LOAD = 1,
-    DRY_CONTACT_SMART_LOAD = 2,
-    PEAK_SHAVING = 3,
-    BACKUP_MODE = 4,
-    SMART_CHARGE_MODE = 5,
-    ECO_MODE_745 = 6,
+    ECO_MODE = 0
+    DRY_CONTACT_LOAD = 1
+    DRY_CONTACT_SMART_LOAD = 2
+    PEAK_SHAVING = 3
+    BACKUP_MODE = 4
+    SMART_CHARGE_MODE = 5
+    ECO_MODE_745 = 6
     NOT_SET = 85
 
     @classmethod
@@ -29,61 +29,56 @@ class ScheduleType(IntEnum):
         """Detect schedule type from its on/off value"""
         if value in (0, -1):
             return ScheduleType.ECO_MODE
-        elif value in (1, -2):
+        if value in (1, -2):
             return ScheduleType.DRY_CONTACT_LOAD
-        elif value in (2, -3):
+        if value in (2, -3):
             return ScheduleType.DRY_CONTACT_SMART_LOAD
-        elif value in (3, -4):
+        if value in (3, -4):
             return ScheduleType.PEAK_SHAVING
-        elif value in (4, -5):
+        if value in (4, -5):
             return ScheduleType.BACKUP_MODE
-        elif value in (5, -6):
+        if value in (5, -6):
             return ScheduleType.SMART_CHARGE_MODE
-        elif value in (6, -7):
+        if value in (6, -7):
             return ScheduleType.ECO_MODE_745
-        elif value == 85:
+        if value == 85:
             return ScheduleType.NOT_SET
-        else:
-            raise ValueError(f"{value}: on_off value {value} out of range.")
+        raise ValueError(f"{value}: on_off value {value} out of range.")
 
     def power_unit(self):
         """Return unit of power parameter"""
         if self == ScheduleType.PEAK_SHAVING:
             return "W"
-        else:
-            return "%"
+        return "%"
 
     def decode_power(self, value: int) -> int:
         """Decode human readable value of power parameter"""
         if self == ScheduleType.PEAK_SHAVING:
             return value * 10
-        elif self == ScheduleType.ECO_MODE_745:
+        if self == ScheduleType.ECO_MODE_745:
             return int(value / 10)
-        elif self == ScheduleType.NOT_SET:
+        if self == ScheduleType.NOT_SET:
             # Prevent out of range values when changing mode
             return value if -100 <= value <= 100 else int(value / 10)
-        else:
-            return value
+        return value
 
     def encode_power(self, value: int) -> int:
         """Encode human readable value of power parameter"""
         if self == ScheduleType.ECO_MODE:
             return value
-        elif self == ScheduleType.PEAK_SHAVING:
+        if self == ScheduleType.PEAK_SHAVING:
             return int(value / 10)
-        elif self == ScheduleType.ECO_MODE_745:
+        if self == ScheduleType.ECO_MODE_745:
             return value * 10
-        else:
-            return value
+        return value
 
     def is_in_range(self, value: int) -> bool:
         """Check if the value fits in allowed values range"""
         if self == ScheduleType.ECO_MODE:
             return -100 <= value <= 100
-        elif self == ScheduleType.ECO_MODE_745:
+        if self == ScheduleType.ECO_MODE_745:
             return -1000 <= value <= 1000
-        else:
-            return True
+        return True
 
 
 class Voltage(Sensor):
@@ -125,6 +120,19 @@ class CurrentS(Sensor):
         return encode_current_signed(value)
 
 
+class CurrentSmA(Sensor):
+    """Sensor representing current [mA] value encoded in 2 (signed) bytes"""
+
+    def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
+        super().__init__(id_, offset, name, 2, "mA", kind)
+
+    def read_value(self, data: ProtocolResponse):
+        return read_current_signed(data)
+
+    def encode_value(self, value: Any, register_value: bytes = None) -> bytes:
+        return encode_current_signed(value)
+
+
 class Frequency(Sensor):
     """Sensor representing frequency [Hz] value encoded in 2 bytes"""
 
@@ -197,6 +205,17 @@ class Energy4(Sensor):
         return float(value) / 10 if value is not None else None
 
 
+class Energy4W(Sensor):
+    """Sensor representing meter energy [kWh] value encoded in 4 bytes"""
+
+    def __init__(self, id_: str, offset: int, name: str, kind: Optional[SensorKind]):
+        super().__init__(id_, offset, name, 4, "kWh", kind)
+
+    def read_value(self, data: ProtocolResponse):
+        value = read_bytes4(data)
+        return float(value) / 1000 if value is not None else None
+
+
 class Energy8(Sensor):
     """Sensor representing energy [kWh] value encoded in 8 bytes"""
 
@@ -405,9 +424,9 @@ class Timestamp(Sensor):
 class Enum(Sensor):
     """Sensor representing label from enumeration encoded in 1 bytes"""
 
-    def __init__(self, id_: str, offset: int, labels: Dict, name: str, kind: Optional[SensorKind] = None):
+    def __init__(self, id_: str, offset: int, labels: dict[int, str], name: str, kind: Optional[SensorKind] = None):
         super().__init__(id_, offset, name, 1, "", kind)
-        self._labels: Dict = labels
+        self._labels: dict[int, str] = labels
 
     def read_value(self, data: ProtocolResponse):
         return self._labels.get(read_byte(data))
@@ -416,9 +435,9 @@ class Enum(Sensor):
 class EnumH(Sensor):
     """Sensor representing label from enumeration encoded in 1 (high 8 bits of 16bit register)"""
 
-    def __init__(self, id_: str, offset: int, labels: Dict, name: str, kind: Optional[SensorKind] = None):
+    def __init__(self, id_: str, offset: int, labels: dict[int, str], name: str, kind: Optional[SensorKind] = None):
         super().__init__(id_, offset, name, 1, "", kind)
-        self._labels: Dict = labels
+        self._labels: dict[int, str] = labels
 
     def read_value(self, data: ProtocolResponse):
         return self._labels.get(read_byte(data))
@@ -427,9 +446,9 @@ class EnumH(Sensor):
 class EnumL(Sensor):
     """Sensor representing label from enumeration encoded in 1 byte (low 8 bits of 16bit register)"""
 
-    def __init__(self, id_: str, offset: int, labels: Dict, name: str, kind: Optional[SensorKind] = None):
+    def __init__(self, id_: str, offset: int, labels: dict[int, str], name: str, kind: Optional[SensorKind] = None):
         super().__init__(id_, offset, name, 1, "", kind)
-        self._labels: Dict = labels
+        self._labels: dict[int, str] = labels
 
     def read_value(self, data: ProtocolResponse):
         read_byte(data)
@@ -439,9 +458,9 @@ class EnumL(Sensor):
 class Enum2(Sensor):
     """Sensor representing label from enumeration encoded in 2 bytes"""
 
-    def __init__(self, id_: str, offset: int, labels: Dict, name: str, kind: Optional[SensorKind] = None):
+    def __init__(self, id_: str, offset: int, labels: dict[int, str], name: str, kind: Optional[SensorKind] = None):
         super().__init__(id_, offset, name, 2, "", kind)
-        self._labels: Dict = labels
+        self._labels: dict[int, str] = labels
 
     def read_value(self, data: ProtocolResponse):
         return self._labels.get(read_bytes2(data, None, 0))
@@ -450,9 +469,9 @@ class Enum2(Sensor):
 class EnumBitmap4(Sensor):
     """Sensor representing label from bitmap encoded in 4 bytes"""
 
-    def __init__(self, id_: str, offset: int, labels: Dict, name: str, kind: Optional[SensorKind] = None):
+    def __init__(self, id_: str, offset: int, labels: dict[int, str], name: str, kind: Optional[SensorKind] = None):
         super().__init__(id_, offset, name, 4, "", kind)
-        self._labels: Dict = labels
+        self._labels: dict[int, str] = labels
 
     def read_value(self, data: ProtocolResponse) -> Any:
         raise NotImplementedError()
@@ -465,10 +484,10 @@ class EnumBitmap4(Sensor):
 class EnumBitmap22(Sensor):
     """Sensor representing label from bitmap encoded in 2+2 bytes"""
 
-    def __init__(self, id_: str, offsetH: int, offsetL: int, labels: Dict, name: str,
+    def __init__(self, id_: str, offsetH: int, offsetL: int, labels: dict[int, str], name: str,
                  kind: Optional[SensorKind] = None):
         super().__init__(id_, offsetH, name, 2, "", kind)
-        self._labels: Dict = labels
+        self._labels: dict[int, str] = labels
         self._offsetL: int = offsetL
 
     def read_value(self, data: ProtocolResponse) -> Any:
@@ -482,11 +501,11 @@ class EnumBitmap22(Sensor):
 class EnumCalculated(Sensor):
     """Sensor representing label from enumeration of calculated value"""
 
-    def __init__(self, id_: str, getter: Callable[[ProtocolResponse], Any], labels: Dict, name: str,
+    def __init__(self, id_: str, getter: Callable[[ProtocolResponse], Any], labels: dict[int, str], name: str,
                  kind: Optional[SensorKind] = None):
         super().__init__(id_, 0, name, 0, "", kind)
         self._getter: Callable[[ProtocolResponse], Any] = getter
-        self._labels: Dict = labels
+        self._labels: dict[int, str] = labels
 
     def read_value(self, data: ProtocolResponse) -> Any:
         raise NotImplementedError()
@@ -500,23 +519,23 @@ class EcoMode(ABC):
 
     @abstractmethod
     def encode_charge(self, eco_mode_power: int, eco_mode_soc: int = 100) -> bytes:
-        """Answer bytes representing all the time enabled charging eco mode group"""
+        """Answer bytes representing all the time enabled charging eco-mode group"""
 
     @abstractmethod
     def encode_discharge(self, eco_mode_power: int) -> bytes:
-        """Answer bytes representing all the time enabled discharging eco mode group"""
+        """Answer bytes representing all the time enabled discharging eco-mode group"""
 
     @abstractmethod
     def encode_off(self) -> bytes:
-        """Answer bytes representing empty and disabled eco mode group"""
+        """Answer bytes representing empty and disabled eco-mode group"""
 
     @abstractmethod
     def is_eco_charge_mode(self) -> bool:
-        """Answer if it represents the emulated 24/7 fulltime discharge mode"""
+        """Answer if it represents the emulated 24/7 full-time discharge mode"""
 
     @abstractmethod
     def is_eco_discharge_mode(self) -> bool:
-        """Answer if it represents the emulated 24/7 fulltime discharge mode"""
+        """Answer if it represents the emulated 24/7 full-time discharge mode"""
 
     @abstractmethod
     def get_schedule_type(self) -> ScheduleType:
@@ -586,19 +605,19 @@ class EcoModeV1(Sensor, EcoMode):
         raise ValueError
 
     def encode_charge(self, eco_mode_power: int, eco_mode_soc: int = 100) -> bytes:
-        """Answer bytes representing all the time enabled charging eco mode group"""
+        """Answer bytes representing all the time enabled charging eco-mode group"""
         return bytes.fromhex("0000173b{:04x}ff7f".format((-1 * abs(eco_mode_power)) & (2 ** 16 - 1)))
 
     def encode_discharge(self, eco_mode_power: int) -> bytes:
-        """Answer bytes representing all the time enabled discharging eco mode group"""
+        """Answer bytes representing all the time enabled discharging eco-mode group"""
         return bytes.fromhex("0000173b{:04x}ff7f".format(abs(eco_mode_power)))
 
     def encode_off(self) -> bytes:
-        """Answer bytes representing empty and disabled eco mode group"""
+        """Answer bytes representing empty and disabled eco-mode group"""
         return bytes.fromhex("3000300000640000")
 
     def is_eco_charge_mode(self) -> bool:
-        """Answer if it represents the emulated 24/7 fulltime discharge mode"""
+        """Answer if it represents the emulated 24/7 full-time discharge mode"""
         return self.start_h == 0 \
             and self.start_m == 0 \
             and self.end_h == 23 \
@@ -608,7 +627,7 @@ class EcoModeV1(Sensor, EcoMode):
             and self.power < 0
 
     def is_eco_discharge_mode(self) -> bool:
-        """Answer if it represents the emulated 24/7 fulltime discharge mode"""
+        """Answer if it represents the emulated 24/7 full-time discharge mode"""
         return self.start_h == 0 \
             and self.start_m == 0 \
             and self.end_h == 23 \
@@ -707,7 +726,7 @@ class Schedule(Sensor, EcoMode):
         raise ValueError
 
     def encode_charge(self, eco_mode_power: int, eco_mode_soc: int = 100) -> bytes:
-        """Answer bytes representing all the time enabled charging eco mode group"""
+        """Answer bytes representing all the time enabled charging eco-mode group"""
         return bytes.fromhex(
             "0000173b{:02x}7f{:04x}{:04x}{:04x}".format(
                 255 - self.schedule_type,
@@ -716,7 +735,7 @@ class Schedule(Sensor, EcoMode):
                 0 if self.schedule_type != ScheduleType.ECO_MODE_745 else 0x0fff))
 
     def encode_discharge(self, eco_mode_power: int) -> bytes:
-        """Answer bytes representing all the time enabled discharging eco mode group"""
+        """Answer bytes representing all the time enabled discharging eco-mode group"""
         return bytes.fromhex("0000173b{:02x}7f{:04x}0064{:04x}".format(
             255 - self.schedule_type,
             abs(self.schedule_type.encode_power(eco_mode_power)),
@@ -729,7 +748,7 @@ class Schedule(Sensor, EcoMode):
             self.schedule_type.encode_power(100)))
 
     def is_eco_charge_mode(self) -> bool:
-        """Answer if it represents the emulated 24/7 fulltime discharge mode"""
+        """Answer if it represents the emulated 24/7 full-time discharge mode"""
         return self.start_h == 0 \
             and self.start_m == 0 \
             and self.end_h == 23 \
@@ -740,7 +759,7 @@ class Schedule(Sensor, EcoMode):
             and (self.month_bits == 0 or self.month_bits == 0x0fff)
 
     def is_eco_discharge_mode(self) -> bool:
-        """Answer if it represents the emulated 24/7 fulltime discharge mode"""
+        """Answer if it represents the emulated 24/7 full-time discharge mode"""
         return self.start_h == 0 \
             and self.start_m == 0 \
             and self.end_h == 23 \
@@ -873,8 +892,7 @@ def read_float4(buffer: ProtocolResponse, offset: int = None) -> float:
     data = buffer.read(4)
     if len(data) == 4:
         return unpack('>f', data)[0]
-    else:
-        return float(0)
+    return float(0)
 
 
 def read_voltage(buffer: ProtocolResponse, offset: int = None) -> float:
@@ -931,8 +949,7 @@ def read_temp(buffer: ProtocolResponse, offset: int = None) -> float | None:
     value = int.from_bytes(buffer.read(2), byteorder="big", signed=True)
     if value == -1 or value == 32767:
         return None
-    else:
-        return float(value) / 10
+    return float(value) / 10
 
 
 def read_datetime(buffer: ProtocolResponse, offset: int = None) -> datetime:
@@ -970,10 +987,9 @@ def read_grid_mode(buffer: ProtocolResponse, offset: int = None) -> int:
     value = read_bytes2_signed(buffer, offset)
     if value < -90:
         return 2
-    elif value >= 90:
+    if value >= 90:
         return 1
-    else:
-        return 0
+    return 0
 
 
 def read_unsigned_int(data: bytes, offset: int) -> int:
@@ -981,7 +997,7 @@ def read_unsigned_int(data: bytes, offset: int) -> int:
     return int.from_bytes(data[offset:offset + 2], byteorder="big", signed=False)
 
 
-def decode_bitmap(value: int, bitmap: Dict[int, str]) -> str:
+def decode_bitmap(value: int, bitmap: dict[int, str]) -> str:
     bits = value
     result = []
     for i in range(32):
@@ -995,7 +1011,7 @@ def decode_bitmap(value: int, bitmap: Dict[int, str]) -> str:
 def decode_day_of_week(data: int) -> str:
     if data == -1:
         return "Mon-Sun"
-    elif data == 0:
+    if data == 0:
         return ""
     bits = bin(data)[2:]
     daynames = list(DAY_NAMES)

{goodwe-0.4.8.dist-info → goodwe-0.4.9.dist-info}/METADATA

@@ -1,16 +1,15 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: goodwe
-Version: 0.4.8
+Version: 0.4.9
 Summary: Read data from GoodWe inverter via local network
 Home-page: https://github.com/marcelblijleven/goodwe
 Author: Martin Letenay, Marcel Blijleven
-Author-email: 'marcelblijleven@gmail.com
+Author-email: marcelblijleven@gmail.com
 License: MIT
 Keywords: GoodWe,Solar Panel,Inverter,Photovoltaics,PV
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -21,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 # GoodWe
 

goodwe-0.4.9.dist-info/RECORD

@@ -0,0 +1,16 @@
+goodwe/__init__.py,sha256=z3tGJH2PxQx8tmmkQ-4r0Y0Z6gFFilut2Il3_TL5LM4,6339
+goodwe/const.py,sha256=g8AtKwrqcoC0YoQrBqWzQb72mt4Jxcn4N4CuWy3zr9k,8062
+goodwe/dt.py,sha256=UIwrqi1eJ7O0S4hB9nzNNilQZ40sLIlH-jGJ4JlwAOs,18434
+goodwe/es.py,sha256=4yWqxJgi8AYhktuHomcjieRjRchzInbZmA0Mbx8_W5Y,24463
+goodwe/et.py,sha256=2kqlrXuoW5D3zjIX1TxiQhNVRbrkAPe9LCpT_nJJZSc,52596
+goodwe/exceptions.py,sha256=Rw2R9SY1T6pDQ1OCQ-dZf-WcG2_WhM5Ensd4ZtYYykk,1436
+goodwe/inverter.py,sha256=_BRjqVnz6dwS0OLbb_3IyyEmV9GuQJQlasNgiCoe4CM,16394
+goodwe/modbus.py,sha256=qWkoxfdnCHvkdD15dt3emzpTPv2liQ_jfTDqrUrBMcU,8440
+goodwe/model.py,sha256=Mw1u2FMA7RKwniL-baO4dydnfwmNbK_jI17AagVAmb8,2515
+goodwe/protocol.py,sha256=TdvjnahOuH-9rXWUnWdKT49VV7xq67FGw4EvB9SHK9Q,30035
+goodwe/sensor.py,sha256=WPVaaHKsLSu8xJdS6lYTVCVkzoRvo80Qh9CxwOUid5o,39287
+goodwe-0.4.9.dist-info/licenses/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
+goodwe-0.4.9.dist-info/METADATA,sha256=ixBMzrLyiksoFS_1IB8XUdxMBr57PRHoj-GbevIUaPA,3346
+goodwe-0.4.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+goodwe-0.4.9.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
+goodwe-0.4.9.dist-info/RECORD,,

{goodwe-0.4.8.dist-info → goodwe-0.4.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

goodwe-0.4.8.dist-info/RECORD

@@ -1,16 +0,0 @@
-goodwe/__init__.py,sha256=8fFGBBvBpCo6Ew4puTtW0kYo2hVPKUx6z5A-TA4Tbvc,5795
-goodwe/const.py,sha256=yhWk56YV7k7-MbgfmWEMYNlqeRNLOfOpfTqEfRj6Hp8,7934
-goodwe/dt.py,sha256=IJxLDajuu2psYE5ZpwA2HFJDFdK5JIST6kUqWyRVBko,13663
-goodwe/es.py,sha256=vvHmxcFykp8nhR1I8p7SF0YcYpvdCKBYacgcolbVHXI,23009
-goodwe/et.py,sha256=Sdgqj13DXIg36NptkHMKxuP78oo4aUQ_6zlToyt78qI,46002
-goodwe/exceptions.py,sha256=dKMLxotjoR1ic8OVlw1joIJ4mKWD6oFtUMZ86fNM5ZE,1403
-goodwe/inverter.py,sha256=86aMJzJjNOr1I_tCF5H6mBwzDTjLbGDKUL2hbi0XSxg,10459
-goodwe/modbus.py,sha256=Mg_s_v8kbZgqXZM6ZUUxkZx2boAG8LkuDG5OiFKK2X4,8402
-goodwe/model.py,sha256=OAKfw6ggClgLR9JIdNd7tQ4pnh_7o_UqVdm1KOVsm-Y,2200
-goodwe/protocol.py,sha256=2xRo1H53G6T0ANSuYKPK_KTNfCVTctIU2ZHVu-CvMPk,30163
-goodwe/sensor.py,sha256=xeDZIwjJ_176ULrRXVCTYvVXx6o2_pWgS0KuR3PPQdg,38435
-goodwe-0.4.8.dist-info/LICENSE,sha256=aZAhk3lRdYT1YZV-IKRHISEcc_KNUmgfuNO3QhRamNM,1073
-goodwe-0.4.8.dist-info/METADATA,sha256=kla7IF_7dMZl-uEdQnGqMBXOkOyNlKt9Inwmi4BWCWQ,3376
-goodwe-0.4.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-goodwe-0.4.8.dist-info/top_level.txt,sha256=kKoiqiVvAxDaDJYMZZQLgHQj9cuWT1MXLfXElTDuf8s,7
-goodwe-0.4.8.dist-info/RECORD,,