indevolt-api 1.0.0__tar.gz

indevolt_api-1.0.0/LICENSE

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

indevolt_api-1.0.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: indevolt-api
+Version: 1.0.0
+Summary: Python API client for Indevolt devices
+Author: A. Gideonse
+License: MIT
+Project-URL: Homepage, https://github.com/xirtnl/indevolt-api
+Project-URL: Repository, https://github.com/xirtnl/indevolt-api
+Project-URL: Issues, https://github.com/xirtnl/indevolt-api/issues
+Keywords: indevolt,api,async,aiohttp
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Hardware
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
+Dynamic: license-file
+
+# Indevolt API
+
+Python client library for communicating with Indevolt devices (home battery systems).
+
+## Features
+
+- Async/await support using aiohttp
+- Fully typed with type hints
+- Simple and intuitive API
+- Comprehensive error handling
+
+## Installation
+
+```bash
+pip install indevolt-api
+```
+
+## Quick Start
+
+```python
+import asyncio
+import aiohttp
+from indevolt_api import IndevoltAPI
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        api = IndevoltAPI(host="192.168.1.100", port=8080, session=session)
+        
+        # Get device configuration
+        config = await api.get_config()
+        print(f"Device config: {config}")
+        
+        # Fetch data from specific cJson points
+        data = await api.fetch_data(["7101", "1664"])
+        print(f"Data: {data}")
+        
+        # Write data (single data point) to device
+        response = await api.set_data("1142", 50)
+        print(f"Set data response: {response}")
+        
+        # Write data (multiple data points) to device
+        response = await api.set_data("47015", [2, 700, 5])
+        print(f"Set data response: {response}")
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### IndevoltAPI
+
+#### `__init__(host: str, port: int, session: aiohttp.ClientSession)`
+
+Initialize the API client.
+
+**Parameters:**
+- `host` (str): Device hostname or IP address
+- `port` (int): Device port number (typically 80)
+- `session` (aiohttp.ClientSession): An aiohttp client session
+
+#### `async fetch_data(t: str | list[str]) -> dict[str, Any]`
+
+Fetch data from the device.
+
+**Parameters:**
+- `t`: Single cJson point or list of cJson points to retrieve (e.g., `"7101"` or `["7101", "1664"]`)
+
+**Returns:**
+- Dictionary with device response containing cJson point data
+
+**Example:**
+```python
+# Single point
+data = await api.fetch_data("7101")
+
+# Multiple points
+data = await api.fetch_data(["7101", "1664", "7102"])
+```
+
+#### `async set_data(t: str | int, v: Any) -> dict[str, Any]`
+
+Write data to the device.
+
+**Parameters:**
+- `t`: cJson point identifier (e.g., `"47015"` or `47015`)
+- `v`: Value(s) to write (automatically converted to list of integers)
+
+**Returns:**
+- Dictionary with device response
+
+**Example:**
+```python
+# Single value
+await api.set_data("47016", 100)
+
+# Multiple values
+await api.set_data("47015", [2, 700, 5])
+
+# String or int identifiers
+await api.set_data(47016, "100")
+```
+
+#### `async get_config() -> dict[str, Any]`
+
+Get system configuration from the device.
+
+**Returns:**
+- Dictionary with device system configuration
+
+**Example:**
+```python
+config = await api.get_config()
+print(config)
+```
+
+## Exception Handling
+
+The library provides two custom exceptions:
+
+### `APIException`
+
+Raised when there's a client error during API communication (network errors, HTTP errors).
+
+### `TimeOutException`
+
+Raised when an API request times out (default timeout: 60 seconds).
+
+**Example:**
+```python
+from indevolt_api import IndevoltAPI, APIException, TimeOutException
+
+try:
+    data = await api.fetch_data("7101")
+except TimeOutException:
+    print("Request timed out")
+except APIException as e:
+    print(f"API error: {e}")
+```
+
+## Requirements
+
+- Python 3.11+
+- aiohttp >= 3.9.0
+
+## License
+
+MIT License - see LICENSE file for details

indevolt_api-1.0.0/indevolt_api/__init__.py

@@ -0,0 +1,11 @@
+"""Indevolt API - Python client for Indevolt devices."""
+
+from .client import APIException, IndevoltAPI, TimeOutException
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "IndevoltAPI",
+    "APIException",
+    "TimeOutException",
+]

indevolt_api-1.0.0/indevolt_api/client.py

@@ -0,0 +1,113 @@
+"""API client for HTTP communication with Indevolt devices."""
+
+import json
+from typing import Any
+
+import aiohttp
+
+
+class TimeOutException(Exception):
+    """Raised when an API call times out."""
+
+
+class APIException(Exception):
+    """Raised on client error during API call."""
+
+
+class IndevoltAPI:
+    """Handle all HTTP communication with Indevolt devices."""
+
+    def __init__(self, host: str, port: int, session: aiohttp.ClientSession) -> None:
+        """Initialize the Indevolt API client.
+
+        Args:
+            host: Device hostname or IP address
+            port: Device port number
+            session: aiohttp ClientSession for HTTP requests
+        """
+        self.host = host
+        self.port = port
+        self.session = session
+        self.base_url = f"http://{host}:{port}/rpc"
+        self.timeout = aiohttp.ClientTimeout(total=60)
+
+    async def _request(self, endpoint: str, config_data: dict[str, Any]) -> dict[str, Any]:
+        """Make HTTP request to device endpoint.
+
+        Args:
+            endpoint: RPC endpoint name (e.g., "Indevolt.GetData")
+            config_data: Configuration data to send
+
+        Returns:
+            Device response dictionary
+        """
+        config_param = json.dumps(config_data).replace(" ", "")
+        url = f"{self.base_url}/{endpoint}?config={config_param}"
+
+        try:
+            async with self.session.post(url, timeout=self.timeout) as response:
+                if response.status != 200:
+                    raise APIException(f"HTTP status error: {response.status}")
+                return await response.json()
+
+        except TimeoutError as err:
+            raise TimeOutException(f"{endpoint} Request timed out") from err
+        except aiohttp.ClientError as err:
+            raise APIException(f"{endpoint} Network error: {err}") from err
+
+    async def fetch_data(self, t: Any) -> dict[str, Any]:
+        """Fetch raw JSON data from the device.
+
+        Args:
+            t: cJson Point(s) of the API to retrieve (e.g., ["7101", "1664"] or "7101")
+
+        Returns:
+            Device response dictionary with cJson Point data
+        """
+        if not isinstance(t, list):
+            t = [t]
+
+        return await self._request("Indevolt.GetData", {"t": t})
+
+    async def set_data(self, t: str | int, v: Any) -> dict[str, Any]:
+        """Write/push data to the device.
+
+        Args:
+            t: cJson Point identifier of the API (e.g., "47015" or 47015)
+            v: Value(s) to write (will be converted to list of integers if needed)
+
+        Returns:
+            Device response dictionary
+
+        Example:
+            await api.set_data("47015", [2, 700, 5])
+            await api.set_data("47016", 100)
+            await api.set_data(47016, "100")
+        """
+        # Convert v to list if not already
+        if not isinstance(v, list):
+            v = [v]
+
+        t_int = int(t)
+        v_int = [int(item) for item in v]
+
+        return await self._request("Indevolt.SetData", {"f": 16, "t": t_int, "v": v_int})
+
+    async def get_config(self) -> dict[str, Any]:
+        """Get system configuration from the device.
+
+        Returns:
+            Device system configuration dictionary
+        """
+        url = f"{self.base_url}/Sys.GetConfig"
+
+        try:
+            async with self.session.get(url, timeout=self.timeout) as response:
+                if response.status != 200:
+                    raise APIException(f"HTTP status error: {response.status}")
+                return await response.json()
+
+        except TimeoutError as err:
+            raise TimeOutException("Sys.GetConfig Request timed out") from err
+        except aiohttp.ClientError as err:
+            raise APIException(f"Sys.GetConfig Network error: {err}") from err

indevolt_api-1.0.0/indevolt_api.egg-info/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: indevolt-api
+Version: 1.0.0
+Summary: Python API client for Indevolt devices
+Author: A. Gideonse
+License: MIT
+Project-URL: Homepage, https://github.com/xirtnl/indevolt-api
+Project-URL: Repository, https://github.com/xirtnl/indevolt-api
+Project-URL: Issues, https://github.com/xirtnl/indevolt-api/issues
+Keywords: indevolt,api,async,aiohttp
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Hardware
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
+Dynamic: license-file
+
+# Indevolt API
+
+Python client library for communicating with Indevolt devices (home battery systems).
+
+## Features
+
+- Async/await support using aiohttp
+- Fully typed with type hints
+- Simple and intuitive API
+- Comprehensive error handling
+
+## Installation
+
+```bash
+pip install indevolt-api
+```
+
+## Quick Start
+
+```python
+import asyncio
+import aiohttp
+from indevolt_api import IndevoltAPI
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        api = IndevoltAPI(host="192.168.1.100", port=8080, session=session)
+        
+        # Get device configuration
+        config = await api.get_config()
+        print(f"Device config: {config}")
+        
+        # Fetch data from specific cJson points
+        data = await api.fetch_data(["7101", "1664"])
+        print(f"Data: {data}")
+        
+        # Write data (single data point) to device
+        response = await api.set_data("1142", 50)
+        print(f"Set data response: {response}")
+        
+        # Write data (multiple data points) to device
+        response = await api.set_data("47015", [2, 700, 5])
+        print(f"Set data response: {response}")
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### IndevoltAPI
+
+#### `__init__(host: str, port: int, session: aiohttp.ClientSession)`
+
+Initialize the API client.
+
+**Parameters:**
+- `host` (str): Device hostname or IP address
+- `port` (int): Device port number (typically 80)
+- `session` (aiohttp.ClientSession): An aiohttp client session
+
+#### `async fetch_data(t: str | list[str]) -> dict[str, Any]`
+
+Fetch data from the device.
+
+**Parameters:**
+- `t`: Single cJson point or list of cJson points to retrieve (e.g., `"7101"` or `["7101", "1664"]`)
+
+**Returns:**
+- Dictionary with device response containing cJson point data
+
+**Example:**
+```python
+# Single point
+data = await api.fetch_data("7101")
+
+# Multiple points
+data = await api.fetch_data(["7101", "1664", "7102"])
+```
+
+#### `async set_data(t: str | int, v: Any) -> dict[str, Any]`
+
+Write data to the device.
+
+**Parameters:**
+- `t`: cJson point identifier (e.g., `"47015"` or `47015`)
+- `v`: Value(s) to write (automatically converted to list of integers)
+
+**Returns:**
+- Dictionary with device response
+
+**Example:**
+```python
+# Single value
+await api.set_data("47016", 100)
+
+# Multiple values
+await api.set_data("47015", [2, 700, 5])
+
+# String or int identifiers
+await api.set_data(47016, "100")
+```
+
+#### `async get_config() -> dict[str, Any]`
+
+Get system configuration from the device.
+
+**Returns:**
+- Dictionary with device system configuration
+
+**Example:**
+```python
+config = await api.get_config()
+print(config)
+```
+
+## Exception Handling
+
+The library provides two custom exceptions:
+
+### `APIException`
+
+Raised when there's a client error during API communication (network errors, HTTP errors).
+
+### `TimeOutException`
+
+Raised when an API request times out (default timeout: 60 seconds).
+
+**Example:**
+```python
+from indevolt_api import IndevoltAPI, APIException, TimeOutException
+
+try:
+    data = await api.fetch_data("7101")
+except TimeOutException:
+    print("Request timed out")
+except APIException as e:
+    print(f"API error: {e}")
+```
+
+## Requirements
+
+- Python 3.11+
+- aiohttp >= 3.9.0
+
+## License
+
+MIT License - see LICENSE file for details

indevolt_api-1.0.0/indevolt_api.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+pyproject.toml
+readme.md
+indevolt_api/__init__.py
+indevolt_api/client.py
+indevolt_api.egg-info/PKG-INFO
+indevolt_api.egg-info/SOURCES.txt
+indevolt_api.egg-info/dependency_links.txt
+indevolt_api.egg-info/requires.txt
+indevolt_api.egg-info/top_level.txt

indevolt_api-1.0.0/indevolt_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

indevolt_api-1.0.0/indevolt_api.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.9.0

indevolt_api-1.0.0/indevolt_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+indevolt_api

indevolt_api-1.0.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "indevolt-api"
+version = "1.0.0"
+description = "Python API client for Indevolt devices"
+readme = "readme.md"
+authors = [
+    {name = "A. Gideonse"}
+]
+license = {text = "MIT"}
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Hardware",
+    "Typing :: Typed",
+]
+keywords = ["indevolt", "api", "async", "aiohttp"]
+dependencies = [
+    "aiohttp>=3.9.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/xirtnl/indevolt-api"
+Repository = "https://github.com/xirtnl/indevolt-api"
+Issues = "https://github.com/xirtnl/indevolt-api/issues"
+
+[tool.setuptools]
+packages = ["indevolt_api"]
+
+[tool.setuptools.package-data]
+indevolt_api = ["py.typed"]

indevolt_api-1.0.0/readme.md

@@ -0,0 +1,147 @@
+# Indevolt API
+
+Python client library for communicating with Indevolt devices (home battery systems).
+
+## Features
+
+- Async/await support using aiohttp
+- Fully typed with type hints
+- Simple and intuitive API
+- Comprehensive error handling
+
+## Installation
+
+```bash
+pip install indevolt-api
+```
+
+## Quick Start
+
+```python
+import asyncio
+import aiohttp
+from indevolt_api import IndevoltAPI
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        api = IndevoltAPI(host="192.168.1.100", port=8080, session=session)
+        
+        # Get device configuration
+        config = await api.get_config()
+        print(f"Device config: {config}")
+        
+        # Fetch data from specific cJson points
+        data = await api.fetch_data(["7101", "1664"])
+        print(f"Data: {data}")
+        
+        # Write data (single data point) to device
+        response = await api.set_data("1142", 50)
+        print(f"Set data response: {response}")
+        
+        # Write data (multiple data points) to device
+        response = await api.set_data("47015", [2, 700, 5])
+        print(f"Set data response: {response}")
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### IndevoltAPI
+
+#### `__init__(host: str, port: int, session: aiohttp.ClientSession)`
+
+Initialize the API client.
+
+**Parameters:**
+- `host` (str): Device hostname or IP address
+- `port` (int): Device port number (typically 80)
+- `session` (aiohttp.ClientSession): An aiohttp client session
+
+#### `async fetch_data(t: str | list[str]) -> dict[str, Any]`
+
+Fetch data from the device.
+
+**Parameters:**
+- `t`: Single cJson point or list of cJson points to retrieve (e.g., `"7101"` or `["7101", "1664"]`)
+
+**Returns:**
+- Dictionary with device response containing cJson point data
+
+**Example:**
+```python
+# Single point
+data = await api.fetch_data("7101")
+
+# Multiple points
+data = await api.fetch_data(["7101", "1664", "7102"])
+```
+
+#### `async set_data(t: str | int, v: Any) -> dict[str, Any]`
+
+Write data to the device.
+
+**Parameters:**
+- `t`: cJson point identifier (e.g., `"47015"` or `47015`)
+- `v`: Value(s) to write (automatically converted to list of integers)
+
+**Returns:**
+- Dictionary with device response
+
+**Example:**
+```python
+# Single value
+await api.set_data("47016", 100)
+
+# Multiple values
+await api.set_data("47015", [2, 700, 5])
+
+# String or int identifiers
+await api.set_data(47016, "100")
+```
+
+#### `async get_config() -> dict[str, Any]`
+
+Get system configuration from the device.
+
+**Returns:**
+- Dictionary with device system configuration
+
+**Example:**
+```python
+config = await api.get_config()
+print(config)
+```
+
+## Exception Handling
+
+The library provides two custom exceptions:
+
+### `APIException`
+
+Raised when there's a client error during API communication (network errors, HTTP errors).
+
+### `TimeOutException`
+
+Raised when an API request times out (default timeout: 60 seconds).
+
+**Example:**
+```python
+from indevolt_api import IndevoltAPI, APIException, TimeOutException
+
+try:
+    data = await api.fetch_data("7101")
+except TimeOutException:
+    print("Request timed out")
+except APIException as e:
+    print(f"API error: {e}")
+```
+
+## Requirements
+
+- Python 3.11+
+- aiohttp >= 3.9.0
+
+## License
+
+MIT License - see LICENSE file for details

indevolt_api-1.0.0/setup.cfg

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