python-openevse-http 0.2.2__tar.gz → 0.2.4__tar.gz

{python_openevse_http-0.2.2/python_openevse_http.egg-info → python_openevse_http-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python wrapper for OpenEVSE HTTP API
 Home-page: https://github.com/firstof9/python-openevse-http
 Download-URL: https://github.com/firstof9/python-openevse-http

{python_openevse_http-0.2.2 → python_openevse_http-0.2.4}/openevsehttp/__main__.py

@@ -3,10 +3,10 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime, timedelta, timezone
 import json
 import logging
 import re
+from datetime import datetime, timedelta, timezone
 from typing import Any, Callable, Dict, Union
 
 import aiohttp  # type: ignore
@@ -84,7 +84,13 @@ UPDATE_TRIGGERS = [
 class OpenEVSE:
     """Represent an OpenEVSE charger."""
 
-    def __init__(self, host: str, user: str = "", pwd: str = "") -> None:
+    def __init__(
+        self,
+        host: str,
+        user: str = "",
+        pwd: str = "",
+        session: aiohttp.ClientSession | None = None,
+    ) -> None:
         """Connect to an OpenEVSE charger equipped with wifi or ethernet."""
         self._user = user
         self._pwd = pwd
@@ -97,6 +103,8 @@ class OpenEVSE:
         self.callback: Callable | None = None
         self._loop = None
         self.tasks = None
+        self._session = session
+        self._session_external = session is not None
 
     async def process_request(
         self,
@@ -113,7 +121,9 @@ class OpenEVSE:
         if self._user and self._pwd:
             auth = aiohttp.BasicAuth(self._user, self._pwd)
 
-        async with aiohttp.ClientSession() as session:
+        # Use provided session or create a temporary one
+        if self._session is not None:
+            session = self._session
             http_method = getattr(session, method)
             _LOGGER.debug(
                 "Connecting to %s with data: %s rapi: %s using method %s",
@@ -165,9 +175,59 @@ class OpenEVSE:
             except ContentTypeError as err:
                 _LOGGER.error("Content error: %s", err.message)
                 raise err
-
-            await session.close()
-            return message
+        else:
+            async with aiohttp.ClientSession() as session:
+                http_method = getattr(session, method)
+                _LOGGER.debug(
+                    "Connecting to %s with data: %s rapi: %s using method %s",
+                    url,
+                    data,
+                    rapi,
+                    method,
+                )
+                try:
+                    async with http_method(
+                        url,
+                        data=rapi,
+                        json=data,
+                        auth=auth,
+                    ) as resp:
+                        try:
+                            message = await resp.text()
+                        except UnicodeDecodeError:
+                            _LOGGER.debug("Decoding error")
+                            message = await resp.read()
+                            message = message.decode(errors="replace")
+
+                        try:
+                            message = json.loads(message)
+                        except ValueError:
+                            _LOGGER.warning("Non JSON response: %s", message)
+
+                        if resp.status == 400:
+                            index = ""
+                            if "msg" in message.keys():
+                                index = "msg"
+                            elif "error" in message.keys():
+                                index = "error"
+                            _LOGGER.error("Error 400: %s", message[index])
+                            raise ParseJSONError
+                        if resp.status == 401:
+                            _LOGGER.error("Authentication error: %s", message)
+                            raise AuthenticationError
+                        if resp.status in [404, 405, 500]:
+                            _LOGGER.warning("%s", message)
+
+                        if method == "post" and "config_version" in message:
+                            await self.update()
+                        return message
+
+                except (TimeoutError, ServerTimeoutError) as err:
+                    _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
+                    raise err
+                except ContentTypeError as err:
+                    _LOGGER.error("Content error: %s", err.message)
+                    raise err
 
     async def send_command(self, command: str) -> tuple:
         """Send a RAPI command to the charger and parses the response."""
@@ -204,7 +264,7 @@ class OpenEVSE:
         if not self.websocket:
             # Start Websocket listening
             self.websocket = OpenEVSEWebsocket(
-                self.url, self._update_status, self._user, self._pwd
+                self.url, self._update_status, self._user, self._pwd, self._session
             )
 
     async def test_and_get(self) -> dict:
@@ -573,7 +633,8 @@ class OpenEVSE:
             return None
 
         try:
-            async with aiohttp.ClientSession() as session:
+            if self._session:
+                session = self._session
                 http_method = getattr(session, method)
                 _LOGGER.debug(
                     "Connecting to %s using method %s",
@@ -590,6 +651,24 @@ class OpenEVSE:
                     response["release_notes"] = message["body"]
                     response["release_url"] = message["html_url"]
                     return response
+            else:
+                async with aiohttp.ClientSession() as session:
+                    http_method = getattr(session, method)
+                    _LOGGER.debug(
+                        "Connecting to %s using method %s",
+                        url,
+                        method,
+                    )
+                    async with http_method(url) as resp:
+                        if resp.status != 200:
+                            return None
+                        message = await resp.text()
+                        message = json.loads(message)
+                        response = {}
+                        response["latest_version"] = message["tag_name"]
+                        response["release_notes"] = message["body"]
+                        response["release_url"] = message["html_url"]
+                        return response
 
         except (TimeoutError, ServerTimeoutError):
             _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
@@ -896,37 +975,32 @@ class OpenEVSE:
             raise UnknownError
 
     @property
-    def led_brightness(self) -> str:
+    def led_brightness(self) -> int | None:
         """Return charger led_brightness."""
         if not self._version_check("4.1.0"):
             _LOGGER.debug("Feature not supported for older firmware.")
             raise UnsupportedFeature
-        assert self._config is not None
-        return self._config["led_brightness"]
+        return self._config.get("led_brightness")
 
     @property
-    def hostname(self) -> str:
+    def hostname(self) -> str | None:
         """Return charger hostname."""
-        assert self._config is not None
-        return self._config["hostname"]
+        return self._config.get("hostname")
 
     @property
-    def wifi_ssid(self) -> str:
+    def wifi_ssid(self) -> str | None:
         """Return charger connected SSID."""
-        assert self._config is not None
-        return self._config["ssid"]
+        return self._config.get("ssid")
 
     @property
-    def ammeter_offset(self) -> int:
+    def ammeter_offset(self) -> int | None:
         """Return ammeter's current offset."""
-        assert self._config is not None
-        return self._config["offset"]
+        return self._config.get("offset")
 
     @property
-    def ammeter_scale_factor(self) -> int:
+    def ammeter_scale_factor(self) -> int | None:
         """Return ammeter's current scale factor."""
-        assert self._config is not None
-        return self._config["scale"]
+        return self._config.get("scale")
 
     @property
     def temp_check_enabled(self) -> bool:
@@ -954,23 +1028,21 @@ class OpenEVSE:
         return bool(self._config.get("relayt", False))
 
     @property
-    def service_level(self) -> str:
+    def service_level(self) -> str | None:
         """Return the service level."""
-        assert self._config is not None
-        return self._config["service"]
+        return self._config.get("service")
 
     @property
-    def openevse_firmware(self) -> str:
+    def openevse_firmware(self) -> str | None:
         """Return the firmware version."""
-        assert self._config is not None
-        return self._config["firmware"]
+        return self._config.get("firmware")
 
     @property
     def max_current_soft(self) -> int | None:
         """Return the max current soft."""
-        if self._config is not None and "max_current_soft" in self._config:
-            return self._config["max_current_soft"]
-        return self._status["pilot"]
+        if "max_current_soft" in self._config:
+            return self._config.get("max_current_soft")
+        return self._status.get("pilot")
 
     @property
     async def async_charge_current(self) -> int | None:
@@ -984,9 +1056,9 @@ class OpenEVSE:
             return min(
                 claims["properties"]["charge_current"], self._config["max_current_hard"]
             )
-        if self._config is not None and "max_current_soft" in self._config:
-            return self._config["max_current_soft"]
-        return self._status["pilot"]
+        if "max_current_soft" in self._config:
+            return self._config.get("max_current_soft")
+        return self._status.get("pilot")
 
     @property
     def max_current(self) -> int | None:
@@ -994,33 +1066,29 @@ class OpenEVSE:
         return self._status.get("max_current", None)
 
     @property
-    def wifi_firmware(self) -> str:
+    def wifi_firmware(self) -> str | None:
         """Return the ESP firmware version."""
-        assert self._config is not None
-        value = self._config["version"]
-        if "dev" in value:
+        value = self._config.get("version")
+        if value is not None and "dev" in value:
             _LOGGER.debug("Stripping 'dev' from version.")
             value = value.split(".")
             value = ".".join(value[0:3])
         return value
 
     @property
-    def ip_address(self) -> str:
+    def ip_address(self) -> str | None:
         """Return the ip address."""
-        assert self._status is not None
-        return self._status["ipaddress"]
+        return self._status.get("ipaddress")
 
     @property
-    def charging_voltage(self) -> int:
+    def charging_voltage(self) -> int | None:
         """Return the charging voltage."""
-        assert self._status is not None
-        return self._status["voltage"]
+        return self._status.get("voltage")
 
     @property
-    def mode(self) -> str:
+    def mode(self) -> str | None:
         """Return the mode."""
-        assert self._status is not None
-        return self._status["mode"]
+        return self._status.get("mode")
 
     @property
     def using_ethernet(self) -> bool:
@@ -1028,98 +1096,80 @@ class OpenEVSE:
         return bool(self._status.get("eth_connected", False))
 
     @property
-    def stuck_relay_trip_count(self) -> int:
+    def stuck_relay_trip_count(self) -> int | None:
         """Return the stuck relay count."""
-        assert self._status is not None
-        return self._status["stuckcount"]
+        return self._status.get("stuckcount")
 
     @property
-    def no_gnd_trip_count(self) -> int:
+    def no_gnd_trip_count(self) -> int | None:
         """Return the no ground count."""
-        assert self._status is not None
-        return self._status["nogndcount"]
+        return self._status.get("nogndcount")
 
     @property
-    def gfi_trip_count(self) -> int:
+    def gfi_trip_count(self) -> int | None:
         """Return the GFCI count."""
-        assert self._status is not None
-        return self._status["gfcicount"]
+        return self._status.get("gfcicount")
 
     @property
     def status(self) -> str:
         """Return charger's state."""
-        state = self._status.get("status", states[int(self._status.get("state", 0))])
-        return state
+        return self._status.get("status", states[int(self._status.get("state", 0))])
 
     @property
     def state(self) -> str:
         """Return charger's state."""
-        assert self._status is not None
-        return states[int(self._status["state"])]
+        return states[int(self._status.get("state", 0))]
 
     @property
-    def state_raw(self) -> int:
+    def state_raw(self) -> int | None:
         """Return charger's state int form."""
-        assert self._status is not None
-        return self._status["state"]
+        return self._status.get("state")
 
     @property
-    def charge_time_elapsed(self) -> int:
+    def charge_time_elapsed(self) -> int | None:
         """Return elapsed charging time."""
-        assert self._status is not None
-        return self._status["elapsed"]
+        return self._status.get("elapsed")
 
     @property
-    def wifi_signal(self) -> str:
+    def wifi_signal(self) -> str | None:
         """Return charger's wifi signal."""
-        assert self._status is not None
-        return self._status["srssi"]
+        return self._status.get("srssi")
 
     @property
-    def charging_current(self) -> float:
+    def charging_current(self) -> float | None:
         """Return the charge current.
 
         0 if is not currently charging.
         """
-        assert self._status is not None
-        return self._status["amp"]
+        return self._status.get("amp")
 
     @property
-    def current_capacity(self) -> int:
+    def current_capacity(self) -> int | None:
         """Return the current capacity."""
-        assert self._status is not None
-        return self._status["pilot"]
+        return self._status.get("pilot")
 
     @property
-    def usage_total(self) -> float:
+    def usage_total(self) -> float | None:
         """Return the total energy usage in Wh."""
-        assert self._status is not None
         if "total_energy" in self._status:
-            return self._status["total_energy"]
-        return self._status["watthour"]
+            return self._status.get("total_energy")
+        return self._status.get("watthour")
 
     @property
     def ambient_temperature(self) -> float | None:
         """Return the temperature of the ambient sensor, in degrees Celsius."""
-        assert self._status is not None
-        temp = None
-        if "temp" in self._status and self._status["temp"]:
-            temp = self._status["temp"] / 10
-        else:
-            temp = self._status["temp1"] / 10
-        return temp
+        temp = self._status.get("temp")
+        if temp:
+            return temp / 10
+        return self._status.get("temp1", 0) / 10
 
     @property
     def rtc_temperature(self) -> float | None:
-        """Return the temperature of the real time clock sensor.
-
-        In degrees Celsius.
-        """
-        assert self._status is not None
-        temp = self._status["temp2"] if self._status["temp2"] else None
-        if temp is not None:
-            return temp / 10
-        return None
+        """Return the temperature of the real time clock sensor."""
+        temp = self._status.get("temp2")
+        if temp is None or isinstance(temp, bool):
+            return None
+        return float(temp) / 10
 
     @property
     def ir_temperature(self) -> float | None:
@@ -1127,27 +1177,23 @@ class OpenEVSE:
 
         In degrees Celsius.
         """
-        assert self._status is not None
-        temp = self._status["temp3"] if self._status["temp3"] else None
-        if temp is not None:
-            return temp / 10
-        return None
+        temp = self._status.get("temp3")
+        if temp is None or isinstance(temp, bool):
+            return None
+        return float(temp) / 10
 
     @property
     def esp_temperature(self) -> float | None:
         """Return the temperature of the ESP sensor, in degrees Celsius."""
-        assert self._status is not None
-        if "temp4" in self._status:
-            temp = self._status["temp4"] if self._status["temp4"] else None
-            if temp is not None:
-                return temp / 10
-        return None
+        temp = self._status.get("temp4")
+        if temp is None or isinstance(temp, bool):
+            return None
+        return float(temp) / 10
 
     @property
     def time(self) -> datetime | None:
         """Get the RTC time."""
         value = self._status.get("time")
-
         if value:
             try:
                 return datetime.fromisoformat(value.replace("Z", "+00:00"))
@@ -1156,15 +1202,17 @@ class OpenEVSE:
         return None
 
     @property
-    def usage_session(self) -> float:
+    def usage_session(self) -> float | None:
         """Get the energy usage for the current charging session.
 
         Return the energy usage in Wh.
         """
-        assert self._status is not None
         if "session_energy" in self._status:
-            return self._status["session_energy"]
-        return float(round(self._status["wattsec"] / 3600, 2))
+            return self._status.get("session_energy")
+        wattsec = self._status.get("wattsec")
+        if wattsec is not None:
+            return float(round(wattsec / 3600, 2))
+        return None
 
     @property
     def total_day(self) -> float | None:
@@ -1194,61 +1242,53 @@ class OpenEVSE:
     @property
     def protocol_version(self) -> str | None:
         """Return the protocol version."""
-        assert self._config is not None
-        if self._config["protocol"] == "-":
+        protocol = self._config.get("protocol")
+        if protocol == "-":
             return None
-        return self._config["protocol"]
+        return protocol
 
     @property
-    def vehicle(self) -> str:
+    def vehicle(self) -> bool:
         """Return if a vehicle is connected dto the EVSE."""
-        assert self._status is not None
-        return self._status["vehicle"]
+        return self._status.get("vehicle", False)
 
     @property
-    def ota_update(self) -> str:
+    def ota_update(self) -> bool:
         """Return if an OTA update is active."""
-        assert self._status is not None
-        return self._status["ota_update"]
+        return self._status.get("ota_update", False)
 
     @property
-    def manual_override(self) -> str:
+    def manual_override(self) -> bool:
         """Return if Manual Override is set."""
-        assert self._status is not None
-        return self._status["manual_override"]
+        return self._status.get("manual_override", False)
 
     @property
     def divertmode(self) -> str:
         """Return the divert mode."""
-        assert self._status is not None
-        mode = self._status["divertmode"]
+        mode = self._status.get("divertmode", 1)
         if mode == 1:
             return "fast"
         return "eco"
 
     @property
-    def charge_mode(self) -> str:
+    def charge_mode(self) -> str | None:
         """Return the charge mode."""
-        assert self._config is not None
-        return self._config["charge_mode"]
+        return self._config.get("charge_mode")
 
     @property
-    def available_current(self) -> float:
+    def available_current(self) -> float | None:
         """Return the computed available current for divert."""
-        assert self._status is not None
-        return self._status["available_current"]
+        return self._status.get("available_current")
 
     @property
-    def smoothed_available_current(self) -> float:
+    def smoothed_available_current(self) -> float | None:
         """Return the computed smoothed available current for divert."""
-        assert self._status is not None
-        return self._status["smoothed_available_current"]
+        return self._status.get("smoothed_available_current")
 
     @property
-    def charge_rate(self) -> float:
+    def charge_rate(self) -> float | None:
         """Return the divert charge rate."""
-        assert self._status is not None
-        return self._status["charge_rate"]
+        return self._status.get("charge_rate")
 
     @property
     def divert_active(self) -> bool:
@@ -1266,7 +1306,7 @@ class OpenEVSE:
 
         Calculate Watts base on V*I
         """
-        if self._status is not None and any(
+        if self._status is not None and all(
             key in self._status for key in ["voltage", "amp"]
         ):
             return round(self._status["voltage"] * self._status["amp"], 2)