modbus-event-connect 0.1.0__tar.gz

modbus_event_connect-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 HairingX
+
+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.

modbus_event_connect-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.1
+Name: modbus_event_connect
+Version: 0.1.0
+Summary: A library to easily interface with modbus devices, be it over TCP, unabto etc.
+Home-page: https://github.com/HairingX/modbus_event_connect
+Author: HairingX
+License: MIT
+Keywords: modbus,easy,remote,connect,library
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyModbusTCP==0.3.0
+
+# Modbus Event Connect
+
+Welcome to **Modbus Event Connect** – a user-friendly Python library designed to simplify the configuration of Modbus devices. Whether you're connecting via TCP or Unabto, Modbus Event Connect has got you covered.
+
+## Features
+
+- **Easy Configuration**: Intuitive setup for Modbus devices.
+- **Flexible Connectivity**: Supports connection through TCP or Unabto.
+- **User-Friendly**: Handles the interaction; you just define the Modbus register items.
+
+## Getting Started
+
+1. **Installation**: Install the library using pip.
+    ```bash
+    pip install modbus-event-connect
+    ```
+2. **Basic Usage**: Define your DataPointKeys to a Modbus device with minimal code.
+    ```python
+    from collections.abc import Callable
+    from src.modbus_event_connect import *
+
+    class MyDatapointKey(ModbusDatapointKey):
+        MAJOR_VERSION = "major_version"
+        
+    class MySetpointKey(ModbusSetpointKey):
+        MY_SETPOINT = "my_setpoint"
+
+    class MyModbusDevice(ModbusDeviceBase):
+        def __init__(self, device_info: ModbusDeviceInfo):
+            super().__init__(device_info)
+
+            self._attr_manufacturer="<manufacturer>"
+            self._attr_model_name="<model_name>"
+            self._attr_datapoints = [
+                ModbusDatapoint(key=MyDatapointKey.MAJOR_VERSION, read_address=1, divider=1, signed=True),
+            ]
+            self._attr_setpoints = [
+                ModbusSetpoint(key=MySetpointKey.MY_SETPOINT, read_address=1, write_address=1 ,divider=1, min=1, max=10, signed=True),
+            ]
+
+    class MyModbusDeviceAdapter(ModbusDeviceAdapter):
+
+        def _translate_to_model(self, device_info: ModbusDeviceInfo) -> Callable[[ModbusDeviceInfo], ModbusDevice]|None: 
+            return MyModbusDevice
+
+    class MyModbusTCPEventConnect(ModbusTCPEventConnect):
+    _attr_adapter = MyModbusDeviceAdapter()
+    ```
+
+## Documentation
+### Client Capabilities
+
+The Modbus EventConnect offers a range of methods to facilitate seamless interaction with Modbus devices. Key features include:
+
+- **Subscribe**: Easily subscribe to data points and receive updates.
+- **Unsubscribe**: Manage your subscriptions effortlessly.
+- **Comprehensive Methods**: A variety of methods to handle different Modbus operations.
+
+Let the EventConnect handle the communication, allowing you to focus on responding to changes and managing your Modbus devices efficiently.
+
+
+## Disclaimer
+
+Modbus Event Connect is provided "as is", without warranty of any kind. The authors and contributors are not responsible for any damage or data loss that may occur from using this library. Users are solely responsible for ensuring the proper and safe operation of their Modbus devices.
+
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

modbus_event_connect-0.1.0/README.md

@@ -0,0 +1,69 @@
+# Modbus Event Connect
+
+Welcome to **Modbus Event Connect** – a user-friendly Python library designed to simplify the configuration of Modbus devices. Whether you're connecting via TCP or Unabto, Modbus Event Connect has got you covered.
+
+## Features
+
+- **Easy Configuration**: Intuitive setup for Modbus devices.
+- **Flexible Connectivity**: Supports connection through TCP or Unabto.
+- **User-Friendly**: Handles the interaction; you just define the Modbus register items.
+
+## Getting Started
+
+1. **Installation**: Install the library using pip.
+    ```bash
+    pip install modbus-event-connect
+    ```
+2. **Basic Usage**: Define your DataPointKeys to a Modbus device with minimal code.
+    ```python
+    from collections.abc import Callable
+    from src.modbus_event_connect import *
+
+    class MyDatapointKey(ModbusDatapointKey):
+        MAJOR_VERSION = "major_version"
+        
+    class MySetpointKey(ModbusSetpointKey):
+        MY_SETPOINT = "my_setpoint"
+
+    class MyModbusDevice(ModbusDeviceBase):
+        def __init__(self, device_info: ModbusDeviceInfo):
+            super().__init__(device_info)
+
+            self._attr_manufacturer="<manufacturer>"
+            self._attr_model_name="<model_name>"
+            self._attr_datapoints = [
+                ModbusDatapoint(key=MyDatapointKey.MAJOR_VERSION, read_address=1, divider=1, signed=True),
+            ]
+            self._attr_setpoints = [
+                ModbusSetpoint(key=MySetpointKey.MY_SETPOINT, read_address=1, write_address=1 ,divider=1, min=1, max=10, signed=True),
+            ]
+
+    class MyModbusDeviceAdapter(ModbusDeviceAdapter):
+
+        def _translate_to_model(self, device_info: ModbusDeviceInfo) -> Callable[[ModbusDeviceInfo], ModbusDevice]|None: 
+            return MyModbusDevice
+
+    class MyModbusTCPEventConnect(ModbusTCPEventConnect):
+    _attr_adapter = MyModbusDeviceAdapter()
+    ```
+
+## Documentation
+### Client Capabilities
+
+The Modbus EventConnect offers a range of methods to facilitate seamless interaction with Modbus devices. Key features include:
+
+- **Subscribe**: Easily subscribe to data points and receive updates.
+- **Unsubscribe**: Manage your subscriptions effortlessly.
+- **Comprehensive Methods**: A variety of methods to handle different Modbus operations.
+
+Let the EventConnect handle the communication, allowing you to focus on responding to changes and managing your Modbus devices efficiently.
+
+
+## Disclaimer
+
+Modbus Event Connect is provided "as is", without warranty of any kind. The authors and contributors are not responsible for any damage or data loss that may occur from using this library. Users are solely responsible for ensuring the proper and safe operation of their Modbus devices.
+
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

modbus_event_connect-0.1.0/pyproject.toml

@@ -0,0 +1,9 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+log_cli = true
+log_cli_level = "DEBUG"
+log_cli_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"

modbus_event_connect-0.1.0/setup.cfg

@@ -0,0 +1,33 @@
+[metadata]
+name = modbus_event_connect
+version = attr: modbus_event_connect.__version__
+author = HairingX
+license = MIT
+description = A library to easily interface with modbus devices, be it over TCP, unabto etc.
+keywords = modbus, easy, remote, connect, library
+url = https://github.com/HairingX/modbus_event_connect
+long_description = file: README.md
+long_description_content_type = text/markdown
+classifiers = 
+	Development Status :: 3 - Alpha
+	Programming Language :: Python :: 3.12
+	Intended Audience :: Developers
+	Topic :: Software Development :: Libraries
+	License :: OSI Approved :: MIT License
+
+[options]
+python_requires = >=3.12
+packages = find:
+package_dir = 
+	=src
+zip_safe = False
+install_requires = 
+	pyModbusTCP ==0.3.0
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

modbus_event_connect-0.1.0/setup.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python
+
+import setuptools
+
+if __name__ == "__main__":
+    setuptools.setup() # type: ignore

modbus_event_connect-0.1.0/src/modbus_event_connect/__init__.py

@@ -0,0 +1,42 @@
+from .modbus_event_connect import ( ModbusEventConnect )
+from .modbus_deviceadapter import ( ModbusDeviceAdapter )
+from .modbus_models import ( 
+        ModbusDevice, 
+        ModbusDeviceBase, 
+        ModbusDeviceInfo,
+        ModbusDatapoint, 
+        ModbusDatapointKey, 
+        ModbusParser,
+        ModbusPointKey, 
+        ModbusSetpoint, 
+        ModbusSetpointKey, 
+        MODBUS_VALUE_TYPES,
+        MODIFIER,
+        UOM,
+        VersionInfo,
+        )
+from .micro_nabto.micro_nabto_connection import ( MicroNabtoModbusDeviceInfo )
+from .micro_nabto.micro_nabto_event_connect import ( MicroNabtoEventConnect )
+from .modbus_tcp.modbus_tcp_event_connect import ( ModbusTCPEventConnect )
+
+__version__ = "0.1.0"
+__all__ = [
+    "ModbusDevice",
+    "ModbusDeviceAdapter",
+    "ModbusDeviceBase",
+    "ModbusDeviceInfo",
+    "ModbusDatapoint",
+    "ModbusDatapointKey",
+    "ModbusParser",
+    "ModbusPointKey",
+    "ModbusEventConnect",
+    "ModbusSetpoint",
+    "ModbusSetpointKey",
+    "MODBUS_VALUE_TYPES",
+    "MODIFIER",
+    "UOM",
+    "MicroNabtoEventConnect",
+    "MicroNabtoModbusDeviceInfo",
+    "ModbusTCPEventConnect",
+    "VersionInfo",
+]

modbus_event_connect-0.1.0/src/modbus_event_connect/modbus_deviceadapter.py

@@ -0,0 +1,98 @@
+import logging
+from typing import Dict, List, Tuple
+from collections.abc import Callable
+
+from .modbus_models import ( MODBUS_VALUE_TYPES, ModbusDeviceInfo, ModbusPointKey, ModbusDevice, ModbusDatapoint, ModbusDatapointKey, ModbusSetpoint, ModbusSetpointKey )
+
+_LOGGER = logging.getLogger(__name__)
+
+class ModbusDeviceAdapter(ModbusDevice):
+    _device_info: ModbusDeviceInfo
+    _loaded_model: ModbusDevice|None
+    
+    def __init__(self):
+        pass
+    
+    def instantiate(self, device_info: ModbusDeviceInfo) -> None:
+        self._device_info = device_info
+        model_to_load = self._translate_to_model(device_info)
+        if model_to_load == None:
+            raise Exception("Invalid model")
+        loaded_model = model_to_load(device_info)
+        loaded_model.instantiate(device_info)
+        self._loaded_model = loaded_model
+        self.ready = True
+     
+    def _translate_to_model(self, device_info: ModbusDeviceInfo) -> Callable[[ModbusDeviceInfo], ModbusDevice]|None:
+        """Translate the model to the correct device model, must be implemented in the subclass"""
+        raise NotImplementedError("Method not implemented")
+
+    def provides_model(self, device_info: ModbusDeviceInfo) -> bool:
+        return self._translate_to_model(device_info) is not None
+    
+    #region ModbusDevice
+    
+    def _get_loaded_model(self) -> ModbusDevice:
+        if self._loaded_model is None:
+            raise Exception("No model loaded")
+        return self._loaded_model
+
+    def get_datapoint(self, key: ModbusDatapointKey) -> ModbusDatapoint|None:
+        return self._get_loaded_model().get_datapoint(key)
+
+    def get_datapoints_for_read(self) -> List[ModbusDatapoint]:
+        return self._get_loaded_model().get_datapoints_for_read()
+
+    @property
+    def device_id(self): return self._get_loaded_model().device_id
+    @property
+    def device_host(self): return self._get_loaded_model().device_host
+    @property
+    def device_port(self): return self._get_loaded_model().device_port
+    @property
+    def identification(self): return self._get_loaded_model().identification
+    @property
+    def manufacturer(self): return self._get_loaded_model().manufacturer
+    @property
+    def model_name(self): return self._get_loaded_model().model_name
+    @property
+    def version(self): return self._get_loaded_model().version
+    
+    
+    def get_max_value(self, key: ModbusSetpointKey) -> float|int|None:
+        return self._get_loaded_model().get_max_value(key)
+
+    def get_min_value(self, key: ModbusSetpointKey) -> float|int|None:
+        return self._get_loaded_model().get_min_value(key)
+
+    def get_setpoint(self, key: ModbusSetpointKey) -> ModbusSetpoint|None:
+        return self._get_loaded_model().get_setpoint(key)
+
+    def get_setpoint_step(self, key: ModbusSetpointKey) -> float|int:
+        return self._get_loaded_model().get_setpoint_step(key)
+
+    def get_setpoints_for_read(self) -> List[ModbusSetpoint]:
+        return self._get_loaded_model().get_setpoints_for_read()
+    
+    def get_unit_of_measure(self, key: ModbusPointKey) -> str|None:
+        return self._get_loaded_model().get_unit_of_measure(key)
+    
+    def get_value(self, key: ModbusPointKey) -> MODBUS_VALUE_TYPES|None:
+        return self._get_loaded_model().get_value(key)
+   
+    def get_values(self) -> Dict[ModbusPointKey, MODBUS_VALUE_TYPES|None]:
+        return self._get_loaded_model().get_values()
+    
+    def has_value(self, key: ModbusPointKey) -> bool:
+        return self._get_loaded_model().has_value(key)
+
+    def provides(self, key: ModbusPointKey) -> bool:
+        return self._get_loaded_model().provides(key)
+
+    def set_read(self, key: ModbusPointKey, read: bool) -> bool:
+        return self._get_loaded_model().set_read(key, read)
+
+    def set_value(self, key: ModbusPointKey, value: MODBUS_VALUE_TYPES) -> Tuple[MODBUS_VALUE_TYPES|None, MODBUS_VALUE_TYPES|None]:
+        return self._get_loaded_model().set_value(key, value)
+    
+    #endregion ModbusDevice

modbus_event_connect-0.1.0/src/modbus_event_connect/modbus_event_connect.py

@@ -0,0 +1,87 @@
+
+from abc import ABC, abstractmethod
+from typing import AsyncGenerator, Callable, Dict, List, Tuple
+
+from .modbus_models import MODBUS_VALUE_TYPES, ModbusDatapoint, ModbusDatapointKey, ModbusSetpoint, ModbusSetpointKey
+from .modbus_deviceadapter import ModbusDeviceAdapter
+
+class ModbusEventConnect(ABC):
+    _attr_adapter: ModbusDeviceAdapter
+    _subscribers: Dict[ModbusDatapointKey|ModbusSetpointKey, List[Callable[[MODBUS_VALUE_TYPES|None, MODBUS_VALUE_TYPES|None], None]]] = {}
+    """Callable[old_value, new_value]"""
+    
+    @abstractmethod
+    def is_connected(self) -> bool: 
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def stop(self) -> None:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def _request_datapoint_data(self, points: List[ModbusDatapoint]) -> AsyncGenerator[Tuple[ModbusDatapoint, MODBUS_VALUE_TYPES], None]:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def _request_setpoint_data(self, points: List[ModbusSetpoint]) -> AsyncGenerator[Tuple[ModbusSetpoint, MODBUS_VALUE_TYPES], None]:
+        raise NotImplementedError("Method not implemented")
+        
+    @property
+    def version(self): return self._attr_adapter.version
+    @property
+    def device_host(self): return self._attr_adapter.device_host
+    @property
+    def device_id(self): return self._attr_adapter.device_id
+    @property
+    def device_port(self): return self._attr_adapter.device_port
+    @property
+    def identification(self): return self._attr_adapter.identification
+    @property
+    def manufacturer(self): return self._attr_adapter.manufacturer
+    @property
+    def model_name(self) -> str: return self._attr_adapter.model_name
+    
+    async def request_datapoint_data(self) -> None:
+        """Request the current value of all subscribed datapoints. All subscribers will be notified of the new value if changed."""
+        points = self._attr_adapter.get_datapoints_for_read()
+        async for point, value in self._request_datapoint_data(points):
+            self._set_value(point.key, value)
+            
+    async def request_setpoint_data(self) -> None:
+        """Request the current value of all subscribed setpoints. All subscribers will be notified of the new value if changed."""
+        points = self._attr_adapter.get_setpoints_for_read()
+        async for point, value in self._request_setpoint_data(points):
+            self._set_value(point.key, value)
+    
+    def subscribe(self, key: ModbusDatapointKey|ModbusSetpointKey, update_method: Callable[[MODBUS_VALUE_TYPES|None, MODBUS_VALUE_TYPES|None], None]):
+        """
+            Subscribe to a datapoint or setpoint value change.
+            
+            :param key: The key of the datapoint or setpoint to subscribe to.
+            :param update_method: The method to call when the value changes. The Callable will receive old_value and new_value as the two inputs.
+            """
+        if key not in self._subscribers:
+            self._subscribers[key] = []
+            self._attr_adapter.set_read(key, True)
+        self._subscribers[key].append(update_method)
+        value = self._attr_adapter.get_value(key)
+        if value is not None:
+            update_method(None, value)
+    
+    def unsubscribe(self, key: ModbusDatapointKey|ModbusSetpointKey, update_method: Callable[[MODBUS_VALUE_TYPES|None, MODBUS_VALUE_TYPES|None], None]):
+        """Remove a subscription to a datapoint or setpoint value change."""
+        subscribers = self._subscribers.get(key)
+        if subscribers is None: return
+        if update_method in subscribers:
+            if len(subscribers) == 1:
+                del self._subscribers[key]
+                self._attr_adapter.set_read(key, False)
+            else: 
+                subscribers.remove(update_method)
+    
+    def _set_value(self, key: ModbusDatapointKey|ModbusSetpointKey, value: MODBUS_VALUE_TYPES):
+        oldval, newval = self._attr_adapter.set_value(key, value)
+        self._notify_subscribers(key, oldval, newval)
+    
+    def _notify_subscribers(self, key: ModbusDatapointKey|ModbusSetpointKey, old_value: MODBUS_VALUE_TYPES|None, new_value: MODBUS_VALUE_TYPES|None):
+        subscribers = self._subscribers.get(key)
+        if subscribers is None: return
+        for subscriber in subscribers:
+            subscriber(old_value, new_value)

modbus_event_connect-0.1.0/src/modbus_event_connect/modbus_models.py

@@ -0,0 +1,434 @@
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Dict, List, NotRequired, Optional, Tuple, TypedDict
+
+MODBUS_VALUE_TYPES = float|int|str
+
+class ModbusPointKey(StrEnum):
+    pass
+
+class ModbusDatapointKey(ModbusPointKey):
+    pass
+
+class ModbusSetpointKey(ModbusPointKey):
+    pass
+
+class UOM:
+    SECONDS = "seconds"
+    MINUTES = "minutes"
+    HOURS = "hours"
+    DAYS = "days"
+    MONTHS = "months"
+    YEARS = "years"
+    CELSIUS = "celsius"
+    BOOL = "bool"
+    BITMASK = "bitmask"
+    PPM = "ppm"
+    """CONCENTRATION PARTS PER MILLION"""
+    RPM = "rpm"
+    """REVOLUTIONS PER MINUTE"""
+    # INT = "int"
+    # FLOAT = "float"
+    PCT = "percent"
+    TEXT = "text"
+    UNKNOWN = None
+    
+class ModbusPointExtras(TypedDict):
+    unit_of_measurement: NotRequired[str|None]
+    """Unit of measurement for the value, UOM class contains the standard units, defaults to None"""
+    always_read: NotRequired[bool|None]
+    """Indication if the point should always be read from the device. If not True, the point will only be read if explicitly requested"""
+    
+@dataclass(kw_only=True)
+class ModbusDatapoint:
+    key: ModbusDatapointKey
+    extra: Optional[ModbusPointExtras|None] = None
+    #read
+    read_address: int
+    signed: bool
+    """indication of the data being signed or unsigned (default=True)"""
+    divider: Optional[int|None] = None
+    """Applied to the register value in the order: 1: divider, 2: offset, 3: modifier"""
+    offset: Optional[int|None] = None
+    """Applied to the register value in the order: 1: divider, 2: offset, 3: modifier"""
+    read_modifier: Optional[Callable[[float|int], float|int]|None] = None
+    """Modifier applied to value after it has been parsed by the system. can be used to alter hours to days etc. or round floating values
+    Applied to the register value in the order: 1: divider, 2: offset, 3: modifier"""
+    read_obj: Optional[int|None] = None
+    """default is 0"""
+
+@dataclass(kw_only=True)
+class ModbusSetpoint:
+    key: ModbusSetpointKey
+    extra: Optional[ModbusPointExtras|None] = None
+    #read
+    read_address: Optional[int|None] = None
+    signed: bool
+    """indication of the data being signed or unsigned (default=True)"""
+    divider: Optional[int|None] = None
+    """Applied to the register value in the order: 1: divider, 2: offset, 3: modifier"""
+    offset: Optional[int|None] = None
+    """Applied to the register value in the order: 1: divider, 2: offset, 3: modifier"""
+    read_modifier: Optional[Callable[[float|int], float|int]|None] = None
+    """Modifier applied to value after it has been parsed by the system. can be used to alter hours to days etc. or round floating values
+    Applied to the register value in the order: 1: divider, 2: offset, 3: modifier"""
+    read_obj: Optional[int|None] = None
+    """default is 0"""
+    #write
+    max: int
+    """max value in the register"""
+    min: int
+    """min value in the register"""
+    write_address: int|None = None
+    step: Optional[int|None] = None
+    """step size in register value, if unset will default to the divider"""
+    write_modifier: Optional[Callable[[float|int], float|int]|None] = None
+    """Modifier applied to value before it has been parsed back to register type. can be used to alter hours to days etc. or round floating values"""
+    write_obj: Optional[int|None] = None
+    """default is 0"""
+
+    
+class ModbusDatapointData:
+    point: ModbusDatapoint
+    read: bool
+    value: MODBUS_VALUE_TYPES|None = None
+    unit_of_measurement: str|None = None
+    def __init__(self, point: ModbusDatapoint):
+        self.point = point
+        self.read = point.extra is not None and "always_read" in point.extra and point.extra["always_read"] == True
+        self.unit_of_measurement = point.extra["unit_of_measurement"] if point.extra is not None and "unit_of_measurement" in point.extra else None
+
+
+class ModbusSetpointData:
+    point: ModbusSetpoint
+    read: bool
+    value: MODBUS_VALUE_TYPES|None = None
+    unit_of_measurement: str|None = None
+    def __init__(self, point: ModbusSetpoint):
+        self.point = point
+        self.read = point.extra is not None and "always_read" in point.extra and point.extra["always_read"] == True
+        self.unit_of_measurement = point.extra["unit_of_measurement"] if point.extra is not None and "unit_of_measurement" in point.extra else None
+
+@dataclass()
+class VersionInfo:
+    major: int
+    minor: int
+    patch: int
+    
+@dataclass(kw_only=True)
+class ModbusDeviceIdenfication:
+    vendor_name: str|None
+    product_code: str|None
+    major_minor_revision: str|None
+    vendor_url: str|None
+    product_name: str|None
+    model_name: str|None
+    user_application_name: str|None
+    
+@dataclass(kw_only=True)
+class ModbusDeviceInfo:
+    device_id: str
+    device_host: str
+    device_port: int
+    version: VersionInfo
+    identification: ModbusDeviceIdenfication|None
+
+class ModbusDevice(ABC):
+    ready: bool = False
+    _device_info: ModbusDeviceInfo
+    
+    def __init__(self, device_info: ModbusDeviceInfo) -> None:
+        self._device_info = device_info
+    
+    def instantiate(self, device_info: ModbusDeviceInfo) -> None:
+        """
+        Sets up the device for usage and raises errors if device has issues.
+        Raises:
+            ValueError: If the an attribute is not set.
+        """
+        self.ready = True
+    
+    @property
+    def device_id(self) -> str: return self._device_info.device_id
+    @property
+    def device_host(self) -> str: return self._device_info.device_host
+    @property
+    def device_port(self) -> int: return self._device_info.device_port
+    @property
+    def identification(self) -> ModbusDeviceIdenfication|None: return self._device_info.identification
+    @property
+    def version(self) -> VersionInfo: return self._device_info.version
+    @property
+    @abstractmethod
+    def manufacturer(self) -> str:
+        raise NotImplementedError("Method not implemented")
+    @property
+    @abstractmethod
+    def model_name(self) -> str:
+        raise NotImplementedError("Method not implemented")
+    
+    @abstractmethod
+    def get_datapoint(self, key: ModbusDatapointKey) -> ModbusDatapoint|None:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_datapoints_for_read(self) -> List[ModbusDatapoint]:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_max_value(self, key: ModbusSetpointKey) -> float|int|None:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_min_value(self, key: ModbusSetpointKey) -> float|int|None:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_setpoint(self, key: ModbusSetpointKey) -> ModbusSetpoint|None:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_setpoint_step(self, key: ModbusSetpointKey) -> float|int:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_setpoints_for_read(self) -> List[ModbusSetpoint]:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_unit_of_measure(self, key: ModbusPointKey) -> str|None:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_value(self, key: ModbusPointKey) -> MODBUS_VALUE_TYPES|None:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def get_values(self) -> Dict[ModbusPointKey, MODBUS_VALUE_TYPES|None]:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def has_value(self, key: ModbusPointKey) -> bool:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def provides(self, key: ModbusPointKey) -> bool:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def set_read(self, key: ModbusPointKey, read: bool) -> bool:
+        raise NotImplementedError("Method not implemented")
+    @abstractmethod
+    def set_value(self, key: ModbusPointKey, value: MODBUS_VALUE_TYPES) -> Tuple[MODBUS_VALUE_TYPES|None, MODBUS_VALUE_TYPES|None]:
+        """Sets the value for the key and returns the old and new value"""
+        raise NotImplementedError("Method not implemented")
+    
+class ModbusDeviceBase(ModbusDevice):
+    _attr_manufacturer:str = ""
+    """Manufacturer of the device. Must be assigned in the __init__ method"""
+    _attr_model_name:str = ""
+    """Model name of the device. Must be assigned in the __init__ method"""
+    _attr_datapoints: List[ModbusDatapoint]
+    """Datapoints for the device. Must be assigned in the __init__ method"""
+    _attr_setpoints: List[ModbusSetpoint]
+    """Setpoints for the device. Must be assigned in the __init__ method"""
+    _attr_default_extras = dict[ModbusPointKey, ModbusPointExtras]()
+    """Default extras for the device. Can be assigned in the __init__ method"""
+    
+    _datapoints = dict[ModbusDatapointKey, ModbusDatapointData]()
+    _setpoints = dict[ModbusSetpointKey, ModbusSetpointData]()
+
+    def __init__(self, device_info: ModbusDeviceInfo) -> None:
+        super().__init__(device_info)
+
+    @property
+    def manufacturer(self) -> str:
+        return self._attr_manufacturer
+    @property
+    def model_name(self) -> str:
+        return self._attr_model_name
+    
+    def instantiate(self, device_info: ModbusDeviceInfo) -> None:
+        if not self._attr_manufacturer:
+            raise ValueError("Manufacturer not set")
+        if not self._attr_model_name:
+            raise ValueError("Model name not set")
+        if not hasattr(self, '_attr_datapoints'):
+            raise ValueError("Datapoints not set")
+        if not hasattr(self, '_attr_setpoints'):
+            raise ValueError("Setpoints not set")
+        
+        for point in self._attr_datapoints:
+            point.extra = point.extra or self._attr_default_extras.get(point.key)
+        self._datapoints = {point.key: ModbusDatapointData(point) for point in self._attr_datapoints}
+        
+        for point in self._attr_setpoints:
+            point.extra = point.extra or self._attr_default_extras.get(point.key)
+        self._setpoints = {point.key: ModbusSetpointData(point) for point in self._attr_setpoints}
+    
+    def get_datapoint(self, key: ModbusDatapointKey) -> ModbusDatapoint | None:
+        data = self._datapoints.get(key)
+        return data.point if data is not None else None
+    
+    def get_datapoints_for_read(self) -> List[ModbusDatapoint]:
+        return [value.point for value in self._datapoints.values() if value.read]
+
+    def get_max_value(self, key: ModbusSetpointKey) -> float | int | None:
+        if self.provides(key):
+            point = self._setpoints[key].point
+            return ModbusParser.parse_from_modbus_value(point=point, value=point.max)
+        return None
+
+    def get_min_value(self, key: ModbusSetpointKey) -> float | int | None:
+        if self.provides(key):
+            point = self._setpoints[key].point
+            return ModbusParser.parse_from_modbus_value(point=point, value=point.min)
+        return None
+
+    def get_setpoint(self, key: ModbusSetpointKey) -> ModbusSetpoint | None:
+        data = self._setpoints.get(key)
+        return data.point if data is not None else None
+    
+    def get_setpoint_step(self, key: ModbusSetpointKey) -> float|int:
+        data = self._setpoints.get(key)
+        if data is not None:
+            divider = ModbusParser.get_point_divider(data.point)    
+            step = ModbusParser.get_point_step(data.point) 
+            if divider > 1: return step / divider
+            return step
+        return 1
+    
+    def get_setpoints_for_read(self) -> List[ModbusSetpoint]:
+        return [value.point for value in self._setpoints.values() if value.read]
+    
+    def get_unit_of_measure(self, key: ModbusPointKey) -> str | None:
+        if isinstance(key, ModbusDatapointKey):
+            data = self._datapoints.get(key)
+            if data is not None:
+                return data.unit_of_measurement
+        elif isinstance(key, ModbusSetpointKey):
+            data = self._setpoints.get(key)
+            if data is not None:
+                return data.unit_of_measurement
+        return None
+
+    def get_value(self, key: ModbusPointKey) -> MODBUS_VALUE_TYPES|None:
+        if isinstance(key, ModbusDatapointKey):
+            point = self._datapoints.get(key)
+            if point is not None:
+                return point.value
+        elif isinstance(key, ModbusSetpointKey):
+            point = self._setpoints.get(key)
+            if point is not None:
+                return point.value
+        return None
+
+    def get_values(self) -> Dict[ModbusPointKey, MODBUS_VALUE_TYPES|None]:
+        datapoints = {key: value.value for key, value in self._datapoints.items() if value.read}
+        setpoints = {key: value.value for key, value in self._setpoints.items() if value.read}
+        return {**datapoints, **setpoints}
+    
+    def has_value(self, key: ModbusPointKey) -> bool:
+        if isinstance(key, ModbusDatapointKey):
+            return key in self._datapoints
+        elif isinstance(key, ModbusSetpointKey):
+            return key in self._setpoints
+        return False
+
+    def provides(self, key: ModbusPointKey) -> bool:
+        return key in self._datapoints or key in self._setpoints
+
+    def set_read(self, key: ModbusPointKey, read: bool) -> bool:
+        """
+        Sets the read state for the point. Returns the new read state.
+        If the device sets the always_read to True in the configuration for the key, the read state can never be set to False.
+        """
+        if key in self._datapoints:
+            self._datapoints[key].read = read
+            return True
+        elif key in self._setpoints:
+            data = self._setpoints[key]
+            if data.point.read_address is not None:
+                data.read = read
+                return True
+        return False
+    
+    def set_value(self, key: ModbusPointKey, value: MODBUS_VALUE_TYPES) -> Tuple[MODBUS_VALUE_TYPES|None, MODBUS_VALUE_TYPES|None]:
+        old_value:MODBUS_VALUE_TYPES|None = None
+        assigned_value:MODBUS_VALUE_TYPES|None = None
+        if key in self._datapoints:
+            data = self._datapoints.get(key)
+            if data is not None:
+                old_value = data.value
+                assigned_value = data.value = value
+        elif key in self._setpoints:
+            data = self._setpoints.get(key)
+            if data is not None:
+                assigned_value = data.value = value
+        return (old_value, assigned_value)
+    
+class MODIFIER:
+    @staticmethod
+    def flip_bool(value:float|int) -> float|int:
+        """Flips the true/false state 
+        - 1 -> 0
+        - 0 -> 1"""
+        return 1-value
+    
+    @staticmethod
+    def seconds_to_minutes(value:float|int) -> float|int:
+        return round(value/60)
+    
+    @staticmethod
+    def hours_to_days(value:float|int) -> float|int:
+        return round(value/24)
+    
+class ModbusParser:
+    @staticmethod
+    def parse_to_modbus_value(point:ModbusSetpoint, value: float|int) -> int:
+        divider = ModbusParser.get_point_divider(point)
+        offset = ModbusParser.get_point_offset(point)
+        modifier = ModbusParser.get_point_write_modifier(point)
+        new_value:float|int = value
+        if modifier is not None: new_value = modifier(new_value)
+        if divider > 1: new_value *= divider
+        if offset != 0: new_value -= offset 
+        return int(new_value) #cast to int, modbus writes only accept an int
+
+    @staticmethod
+    def parse_from_modbus_value(point:ModbusDatapoint|ModbusSetpoint, value: int) -> float|int:
+        divider = ModbusParser.get_point_divider(point)
+        offset = ModbusParser.get_point_offset(point)
+        modifier = ModbusParser.get_point_read_modifier(point)
+        new_value:float|int = value
+        if offset != 0: new_value += offset 
+        if divider > 1: new_value /= divider
+        if modifier is not None: new_value = modifier(new_value)
+        return new_value
+
+    @staticmethod
+    def get_point_divider(point:ModbusDatapoint|ModbusSetpoint) -> int: 
+        return 1 if point.divider is None else point.divider
+    @staticmethod
+    def get_point_offset(point:ModbusDatapoint|ModbusSetpoint) -> int: 
+        return 0 if point.offset is None else point.offset
+    @staticmethod
+    def get_point_read_address(point:ModbusDatapoint|ModbusSetpoint) -> int|None: 
+        return point.read_address
+    @staticmethod
+    def get_point_read_obj(point:ModbusDatapoint|ModbusSetpoint) -> int: 
+        return 0 if point.read_obj is None else point.read_obj
+    @staticmethod
+    def get_point_write_address(point:ModbusSetpoint) -> int|None: 
+        return point.write_address
+    @staticmethod
+    def get_point_write_obj(point:ModbusSetpoint) -> int: 
+        return 0 if point.write_obj is None else point.write_obj
+    @staticmethod
+    def get_point_signed(point:ModbusDatapoint|ModbusSetpoint) -> bool: 
+        return point.signed
+    @staticmethod
+    def get_point_step(point:ModbusSetpoint) -> int: 
+        return 1 if point.step is None else point.step
+    @staticmethod
+    def get_point_max(point:ModbusSetpoint) -> int: 
+        return point.max
+    @staticmethod
+    def get_point_min(point:ModbusSetpoint) -> int: 
+        return point.min
+    @staticmethod
+    def get_point_read_modifier(point:ModbusDatapoint|ModbusSetpoint) -> Callable[[float|int], float|int]|None: 
+        return None if point.read_modifier is None else point.read_modifier
+    @staticmethod
+    def get_point_write_modifier(point: ModbusSetpoint) -> Callable[[float|int], float|int]|None: 
+        return None if point.write_modifier is None else point.write_modifier

modbus_event_connect-0.1.0/src/modbus_event_connect.egg-info/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.1
+Name: modbus_event_connect
+Version: 0.1.0
+Summary: A library to easily interface with modbus devices, be it over TCP, unabto etc.
+Home-page: https://github.com/HairingX/modbus_event_connect
+Author: HairingX
+License: MIT
+Keywords: modbus,easy,remote,connect,library
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyModbusTCP==0.3.0
+
+# Modbus Event Connect
+
+Welcome to **Modbus Event Connect** – a user-friendly Python library designed to simplify the configuration of Modbus devices. Whether you're connecting via TCP or Unabto, Modbus Event Connect has got you covered.
+
+## Features
+
+- **Easy Configuration**: Intuitive setup for Modbus devices.
+- **Flexible Connectivity**: Supports connection through TCP or Unabto.
+- **User-Friendly**: Handles the interaction; you just define the Modbus register items.
+
+## Getting Started
+
+1. **Installation**: Install the library using pip.
+    ```bash
+    pip install modbus-event-connect
+    ```
+2. **Basic Usage**: Define your DataPointKeys to a Modbus device with minimal code.
+    ```python
+    from collections.abc import Callable
+    from src.modbus_event_connect import *
+
+    class MyDatapointKey(ModbusDatapointKey):
+        MAJOR_VERSION = "major_version"
+        
+    class MySetpointKey(ModbusSetpointKey):
+        MY_SETPOINT = "my_setpoint"
+
+    class MyModbusDevice(ModbusDeviceBase):
+        def __init__(self, device_info: ModbusDeviceInfo):
+            super().__init__(device_info)
+
+            self._attr_manufacturer="<manufacturer>"
+            self._attr_model_name="<model_name>"
+            self._attr_datapoints = [
+                ModbusDatapoint(key=MyDatapointKey.MAJOR_VERSION, read_address=1, divider=1, signed=True),
+            ]
+            self._attr_setpoints = [
+                ModbusSetpoint(key=MySetpointKey.MY_SETPOINT, read_address=1, write_address=1 ,divider=1, min=1, max=10, signed=True),
+            ]
+
+    class MyModbusDeviceAdapter(ModbusDeviceAdapter):
+
+        def _translate_to_model(self, device_info: ModbusDeviceInfo) -> Callable[[ModbusDeviceInfo], ModbusDevice]|None: 
+            return MyModbusDevice
+
+    class MyModbusTCPEventConnect(ModbusTCPEventConnect):
+    _attr_adapter = MyModbusDeviceAdapter()
+    ```
+
+## Documentation
+### Client Capabilities
+
+The Modbus EventConnect offers a range of methods to facilitate seamless interaction with Modbus devices. Key features include:
+
+- **Subscribe**: Easily subscribe to data points and receive updates.
+- **Unsubscribe**: Manage your subscriptions effortlessly.
+- **Comprehensive Methods**: A variety of methods to handle different Modbus operations.
+
+Let the EventConnect handle the communication, allowing you to focus on responding to changes and managing your Modbus devices efficiently.
+
+
+## Disclaimer
+
+Modbus Event Connect is provided "as is", without warranty of any kind. The authors and contributors are not responsible for any damage or data loss that may occur from using this library. Users are solely responsible for ensuring the proper and safe operation of their Modbus devices.
+
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

modbus_event_connect-0.1.0/src/modbus_event_connect.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+src/modbus_event_connect/__init__.py
+src/modbus_event_connect/modbus_deviceadapter.py
+src/modbus_event_connect/modbus_event_connect.py
+src/modbus_event_connect/modbus_models.py
+src/modbus_event_connect.egg-info/PKG-INFO
+src/modbus_event_connect.egg-info/SOURCES.txt
+src/modbus_event_connect.egg-info/dependency_links.txt
+src/modbus_event_connect.egg-info/not-zip-safe
+src/modbus_event_connect.egg-info/requires.txt
+src/modbus_event_connect.egg-info/top_level.txt
+tests/test_micro_nabto.py
+tests/test_modbus_tcp.py
+tests/test_test.py

modbus_event_connect-0.1.0/src/modbus_event_connect.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

modbus_event_connect-0.1.0/src/modbus_event_connect.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

modbus_event_connect-0.1.0/src/modbus_event_connect.egg-info/requires.txt

@@ -0,0 +1 @@
+pyModbusTCP==0.3.0

modbus_event_connect-0.1.0/src/modbus_event_connect.egg-info/top_level.txt

@@ -0,0 +1 @@
+modbus_event_connect

modbus_event_connect-0.1.0/tests/test_micro_nabto.py

@@ -0,0 +1,76 @@
+import concurrent.futures
+from dataclasses import dataclass
+# import json
+import threading
+from typing import Any
+import pytest
+
+from credentials import Credentials
+import logging
+
+from src.modbus_event_connect.micro_nabto.micro_nabto_connection import Request
+from src.modbus_event_connect import MODBUS_VALUE_TYPES
+from models.micro_nabto_test_models import ModbusTestDatapointKey, ModbusTestMicroNabto
+import asyncio
+
+_LOGGER = logging.getLogger(__name__)
+
+@dataclass
+class TestData:
+    client: ModbusTestMicroNabto
+    data = dict[str, Any]()
+    credentials: Credentials
+    
+@pytest.fixture
+def testdata():
+    #setup
+    credentials = Credentials(["username", "hostname"])
+    client = ModbusTestMicroNabto()
+    # 
+    yield TestData(client=client, credentials=credentials)
+    #teardown
+    client.stop()
+
+async def test_connection_request():
+    request = Request(1)
+    responsetask = request.wait_for_response()
+    request.notify_waiters()
+    await responsetask
+    
+async def test_connection_request_thread():
+    request = Request( 1)
+    def thread_method():
+        asyncio.run(asyncio.sleep(1))
+        request.notify_waiters()
+    _listen_thread = threading.Thread(target=thread_method)
+    _listen_thread.start()
+    await request.wait_for_response()
+    
+async def test_connection_request_asyncio_loop():
+    request = Request(1)
+    def thread_method():
+        asyncio.run(asyncio.sleep(1))
+        request.notify_waiters()
+    _loop = asyncio.get_event_loop()
+    with concurrent.futures.ThreadPoolExecutor() as pool:
+        _loop.run_in_executor(pool, thread_method)
+    await request.wait_for_response()
+
+async def test_connect(testdata: TestData):
+    credentials = testdata.credentials
+    client = testdata.client
+    success = await client.connect(credentials.username, "DEVICE_ID", credentials.hostname)
+    assert success
+
+async def test_datapoint(testdata: TestData):
+    credentials = testdata.credentials
+    client = testdata.client
+    success = await client.connect(credentials.username, "DEVICE_ID", credentials.hostname)
+    assert success
+    await client.request_datapoint_data()
+    event = asyncio.Event()
+    def callback(oldval:MODBUS_VALUE_TYPES|None, newval:MODBUS_VALUE_TYPES|None):
+        _LOGGER.debug(f"{ModbusTestDatapointKey.MAJOR_VERSION}: {oldval if oldval is not None else 'None'} -> {newval if newval is not None else 'None'}")
+        event.set()
+    client.subscribe(ModbusTestDatapointKey.MAJOR_VERSION, callback)
+    assert await event.wait()

modbus_event_connect-0.1.0/tests/test_modbus_tcp.py

@@ -0,0 +1,76 @@
+import concurrent.futures
+from dataclasses import dataclass
+# import json
+import threading
+from typing import Any
+import pytest
+
+from credentials import Credentials
+import logging
+
+from src.modbus_event_connect.micro_nabto.micro_nabto_connection import Request
+from src.modbus_event_connect import MODBUS_VALUE_TYPES
+from models.modbus_tcp_test_models import ModbusTestDatapointKey, ModbusTestTCP
+import asyncio
+
+_LOGGER = logging.getLogger(__name__)
+
+@dataclass
+class TestData:
+    client: ModbusTestTCP
+    data = dict[str, Any]()
+    credentials: Credentials
+    
+@pytest.fixture
+def testdata():
+    #setup
+    credentials = Credentials(["username", "hostname"])
+    client = ModbusTestTCP()
+    # 
+    yield TestData(client=client, credentials=credentials)
+    #teardown
+    client.stop()
+
+async def test_connection_request():
+    request = Request(1)
+    responsetask = request.wait_for_response()
+    request.notify_waiters()
+    await responsetask
+    
+async def test_connection_request_thread():
+    request = Request( 1)
+    def thread_method():
+        asyncio.run(asyncio.sleep(1))
+        request.notify_waiters()
+    _listen_thread = threading.Thread(target=thread_method)
+    _listen_thread.start()
+    await request.wait_for_response()
+    
+async def test_connection_request_asyncio_loop():
+    request = Request(1)
+    def thread_method():
+        asyncio.run(asyncio.sleep(1))
+        request.notify_waiters()
+    _loop = asyncio.get_event_loop()
+    with concurrent.futures.ThreadPoolExecutor() as pool:
+        _loop.run_in_executor(pool, thread_method)
+    await request.wait_for_response()
+
+async def test_connect(testdata: TestData):
+    credentials = testdata.credentials
+    client = testdata.client
+    success = await client.connect("DEVICE_ID", credentials.hostname)
+    assert success
+
+async def test_datapoint(testdata: TestData):
+    credentials = testdata.credentials
+    client = testdata.client
+    success = await client.connect("DEVICE_ID", credentials.hostname)
+    assert success
+    event = asyncio.Event()
+    def callback(oldval:MODBUS_VALUE_TYPES|None, newval:MODBUS_VALUE_TYPES|None):
+        _LOGGER.debug(f"{ModbusTestDatapointKey.MAJOR_VERSION}: {oldval if oldval is not None else 'None'} -> {newval if newval is not None else 'None'}")
+        event.set()
+    client.subscribe(ModbusTestDatapointKey.MAJOR_VERSION, callback)
+    await client.request_datapoint_data()
+    assert await event.wait()

modbus_event_connect-0.1.0/tests/test_test.py

@@ -0,0 +1,7 @@
+import logging
+_LOGGER = logging.getLogger(__name__)
+
+def test_test():
+    print("hello print")
+    _LOGGER.debug("hello _LOGGER")
+    assert True