megalion-http 0.0.1__py3-none-any.whl

megalion_http/__init__.py

@@ -0,0 +1 @@
+from .megalion import *

megalion_http/auth.py

@@ -0,0 +1,36 @@
+from aiohttp import ClientResponse, ClientSession
+
+class Auth:
+    """Make authenticated requests to the API."""
+
+    def __init__(self, session: ClientSession, host: str,
+                 access_token: str) -> None:
+        """Initialize the auth."""
+        self.session = session
+        self.host = host
+        self.access_token = access_token
+
+    async def update_token(self, username: str, password: str) -> None:
+        response = await self.session.request("post",
+                                              f"https://{self.host}/auth/login",
+                                              json={'username': username,
+                                                    'password': password})
+        response.raise_for_status()
+        data = await response.json()
+        if (data['code'] != 200):
+            raise AuthError(str(data))
+        self.access_token = data['data']['access_token']
+
+    async def request(
+            self, method: str, path: str, **kwargs
+            ) -> ClientResponse:
+        """Make a request."""
+        headers = dict(kwargs.pop("headers", None) or {})
+        headers["authorization"] = f"Bearer {self.access_token}"
+
+        return await self.session.request(
+                method, f"https://{self.host}/{path}", **kwargs, headers=headers
+                )
+
+class AuthError(Exception):
+    pass

megalion_http/battery.py

@@ -0,0 +1,149 @@
+from typing import Any
+
+from .auth import Auth
+
+class Battery:
+    """A Megalion Battery (ESS)"""
+
+    def __init__(self, sn: str, auth: Auth) -> None:
+        """Initialize the battery"""
+        self.device_sn = sn
+        self.auth = auth
+
+    async def async_update(self) -> None:
+        response = await self.auth.request("get", f"system/stationDevice/list?sn={self.device_sn}")
+        response.raise_for_status()
+        raw_data = await response.json()
+        self.raw_data = raw_data['rows'][0]
+        response = await self.auth.request("get", f"system/deviceLatestData/getLatestDataTable?sn={self.device_sn}")
+        response.raise_for_status()
+        raw_detail = await response.json()
+        self.raw_detail = raw_detail['data']
+        response = await self.auth.request("get", f"system/deviceLatestData/getCellVoltages?sn={self.device_sn}")
+        response.raise_for_status()
+        raw_voltages = await response.json()
+        self.raw_voltages = raw_voltages['data']
+        response = await self.auth.request("get", f"system/deviceLatestData/getCellTemperatures?sn={self.device_sn}")
+        response.raise_for_status()
+        raw_temperatures = await response.json()
+        self.raw_temperatures = raw_temperatures['data']
+
+    @property
+    def batchName(self) -> str:
+        return self.raw_data['batchName']
+
+    @property
+    def batteryRatedEnergy(self) -> float:
+        return self.raw_data['batteryRatedEnergy']
+
+    @property
+    def batteryTemperature(self) -> float:
+        return self.raw_data['batteryTemperature']
+
+    @property
+    def chargeStatus(self) -> str:
+        return self.raw_data['chargeStatus']
+
+    @property
+    def createBy(self) -> str:
+        return self.raw_data['createBy']
+
+    @property
+    def createTime(self) -> str:
+        return self.raw_data['createTime']
+
+    @property
+    def createTimeTimezone(self) -> str:
+        return self.raw_data['createTimeTimezone']
+
+    @property
+    def current(self) -> float:
+        return self.raw_data['current']
+
+    @property
+    def dayCharge(self) -> float:
+        return self.raw_data['dayCharge']
+
+    @property
+    def dayDischarge(self) -> float:
+        return self.raw_data['dayDischarge']
+
+    @property
+    def deviceId(self) -> int:
+        return self.raw_data['deviceId']
+
+    @property
+    def deviceModel(self) -> str:
+        return self.raw_data['deviceModel']
+
+    @property
+    def deviceName(self) -> str:
+        return self.raw_data['deviceName']
+
+    @property
+    def deviceStatus(self) -> str:
+        return self.raw_data['deviceStatus']
+
+    @property
+    def deviceType(self) -> str:
+        return self.raw_data['deviceType']
+
+    @property
+    def deviceTypeStr(self) -> str:
+        return self.raw_data['deviceTypeStr']
+
+    @property
+    def dynamicLinkedDeviceSn(self) -> str:
+        return self.raw_data['dynamicLinkedDeviceSn']
+
+    @property
+    def inverterBrand(self) -> str:
+        return self.raw_data['inverterBrand']
+
+    @property
+    def lastOfflineTimeUtc(self) -> str:
+        return self.raw_data['lastOfflineTimeUtc']
+
+    @property
+    def lastOnlineTimeUtc(self) -> str:
+        return self.raw_data['lastOnlineTimeUtc']
+
+    @property
+    def realtimePower(self) -> float:
+        return self.raw_data['realtimePower']
+
+    @property
+    def sn(self) -> str:
+        return self.raw_data['sn']
+
+    @property
+    def soc(self) -> float:
+        return self.raw_data['soc']
+
+    @property
+    def staticLinkedDeviceSn(self) -> str:
+        return self.raw_data['staticLinkedDeviceSn']
+
+    @property
+    def totalCharge(self) -> float:
+        return self.raw_data['totalCharge']
+
+    @property
+    def totalDischarge(self) -> float:
+        return self.raw_data['totalDischarge']
+
+    @property
+    def userId(self) -> str:
+        return self.raw_data['userId']
+
+    @property
+    def voltage(self) -> float:
+        return self.raw_data['voltage']
+
+    @property
+    def cellVoltages(self) -> list[int]:
+        return self.raw_voltages['cellVoltages']
+
+    @property
+    def cellTemperatures(self) -> list[int]:
+        return self.raw_temperatures['cellTemperatures']

megalion_http/megalion.py

@@ -0,0 +1,29 @@
+from .auth import Auth, AuthError
+from .battery import Battery
+from .user import User
+
+class MegalionHubAPI:
+    def __init__(self, auth: Auth) -> None:
+        self.auth = auth
+
+    async def async_get_user(self) -> User:
+        user = User(self.auth)
+        await user.async_update()
+        return user
+
+    async def async_get_batteries(self) -> list[Battery]:
+        response = await self.auth.request("get", f"system/stationDevice/list")
+        response.raise_for_status()
+        raw_data = await response.json()
+        if raw_data['code'] != 200:
+            raise MegalionHubError(str(raw_data))
+        batteries = []
+        for device in raw_data['rows']:
+            if device['deviceType'] == "ENERGY_STORAGE_EQUIPMENT":
+                battery = Battery(device['sn'], self.auth)
+                batteries.append(battery)
+                await battery.async_update()
+        return batteries
+
+class MegalionHubError(Exception):
+    pass

megalion_http/user.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+from .auth import Auth
+
+class User:
+    """A Megalion API User"""
+
+    def __init__(self, auth: Auth) -> None:
+        """Initialize the battery"""
+        self.auth = auth
+
+    async def async_update(self) -> None:
+        response = await self.auth.request("get", f"system/user/getInfo")
+        response.raise_for_status()
+        self.raw_data = await response.json()
+
+    @property
+    def userId(self) -> int:
+        return self.raw_data['user']['userId']
+
+    @property
+    def email(self) -> str:
+        return self.raw_data['user']['email']
+
+    @property
+    def userName(self) -> str:
+        return self.raw_data['user']['userName']

megalion_http-0.0.1.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.5
+Name: megalion-http
+Version: 0.0.1
+Summary: Expose the Megalion HTTP API to python
+Project-URL: Homepage, https://github.com/klarasm/megalion-http
+Project-URL: Issues, https://github.com/klarasm/megalion-http/issues
+Author-email: Klara Modin <klarasmodin@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# Megalion-HTTP
+
+This exposes the Megalion HTTP API to python, for use with HomeAssistant.

megalion_http-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+megalion_http/__init__.py,sha256=Ve9ppD9t70OPnZPoCMKudaU95UvkNybZfQM18A5lVxE,24
+megalion_http/auth.py,sha256=JBrszd2WU9RHhVGqTBIPkUkMArap8qkicSM-JgcJTP8,1351
+megalion_http/battery.py,sha256=ZspVqzNFXsvE9_8fYzA4vLhmMD1evwx47E5Ez3R10hw,4141
+megalion_http/megalion.py,sha256=No-TMeVPky1JgpXZLLhV8YvRX1bfvu3hXIZJbqG_6DY,956
+megalion_http/user.py,sha256=sdcbJ3nFYvPK2IR1KJSH8HIoISWLXPPFT2gIe1EveM8,671
+megalion_http-0.0.1.dist-info/METADATA,sha256=f3wymYS6E5vscEmFiypDw-fY2_HVZ291mpUiAzEOLIU,585
+megalion_http-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+megalion_http-0.0.1.dist-info/licenses/LICENSE,sha256=pD0wGV1gY909BDv8omAOAvcXtwGGTWXWqDKa_9lhPzg,1068
+megalion_http-0.0.1.dist-info/RECORD,,

megalion_http-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

megalion_http-0.0.1.dist-info/licenses/LICENSE

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