python-openevse-http 0.4.3__py3-none-any.whl → 0.4.4__py3-none-any.whl

openevsehttp/client.py

@@ -7,10 +7,10 @@ import inspect
 import json
 import logging
 import threading
-from collections.abc import Callable, Mapping
+from collections.abc import Callable, Mapping, MutableMapping
 from typing import Any
 
-import aiohttp  # type: ignore
+import aiohttp
 from aiohttp.client_exceptions import ContentTypeError, ServerTimeoutError
 from awesomeversion import AwesomeVersion
 from awesomeversion.exceptions import AwesomeVersionCompareException
@@ -56,15 +56,15 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
         self._user = user
         self._pwd = pwd
         self.url = f"http://{host}/"
-        self._status: dict = {}
-        self._config: dict = {}
-        self._override = None
+        self._status: dict[str, Any] = {}
+        self._config: dict[str, Any] = {}
+        self._override: Any = None
         self._ws_listening = False
         self.websocket: OpenEVSEWebsocket | None = None
-        self.callback: Callable | None = None
+        self.callback: Callable[[], Any] | None = None
         self._loop: asyncio.AbstractEventLoop | None = None
-        self._ws_listen_task: asyncio.Task | None = None
-        self._ws_keepalive_task: asyncio.Task | None = None
+        self._ws_listen_task: asyncio.Task[Any] | None = None
+        self._ws_keepalive_task: asyncio.Task[Any] | None = None
         self._owns_loop = False
         self._loop_thread: threading.Thread | None = None
         self._session = session
@@ -76,7 +76,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
         method: str = "",
         data: Any = None,
         rapi: Any = None,
-    ) -> Mapping[str, Any] | list[Any] | str:
+    ) -> Mapping[str, Any] | list[Any] | str | bool:
         """Return result of processed HTTP request."""
         auth = None
         allowed_methods = ["get", "post", "put", "delete", "patch", "head", "options"]
@@ -112,7 +112,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
         data: Any,
         rapi: Any,
         auth: Any,
-    ) -> Mapping[str, Any] | list[Any] | str:
+    ) -> Mapping[str, Any] | list[Any] | str | bool:
         """Process a request with a given session."""
         if not hasattr(session, method):
             raise MissingMethod
@@ -130,38 +130,51 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
                 kwargs["json"] = data
             async with http_method(url, **kwargs) as resp:
                 try:
-                    message = await resp.text()
+                    raw = await resp.text()
                 except UnicodeDecodeError:
                     _LOGGER.debug("Decoding error")
-                    message = await resp.read()
-                    message = message.decode(errors="replace")
+                    raw = (await resp.read()).decode(errors="replace")
 
+                # JSON responses can sometimes be primitive values (like bools).
+                # If json.loads fails with ValueError (e.g. non-JSON text/html),
+                # we fall back to treating the raw response as a string.
+                response_content: Mapping[str, Any] | list[Any] | str | bool = raw
                 try:
-                    message = json.loads(message)
+                    response_content = json.loads(raw)
                 except ValueError:
-                    _LOGGER.debug("Non JSON response: %s", message)
+                    _LOGGER.debug("Non JSON response: %s", raw)
+                if not isinstance(response_content, dict | list | str | bool):
+                    _LOGGER.error(
+                        "Unexpected JSON primitive response from %s: %r",
+                        url,
+                        response_content,
+                    )
+                    raise ParseJSONError
 
                 if resp.status == 400:
-                    if isinstance(message, dict) and "msg" in message:
-                        _LOGGER.error("Error 400: %s", message["msg"])
-                    elif isinstance(message, dict) and "error" in message:
-                        _LOGGER.error("Error 400: %s", message["error"])
+                    if isinstance(response_content, dict) and "msg" in response_content:
+                        _LOGGER.error("Error 400: %s", response_content["msg"])
+                    elif (
+                        isinstance(response_content, dict)
+                        and "error" in response_content
+                    ):
+                        _LOGGER.error("Error 400: %s", response_content["error"])
                     else:
-                        _LOGGER.error("Error 400: %s", message)
+                        _LOGGER.error("Error 400: %s", response_content)
                     raise ParseJSONError
                 if resp.status == 401:
-                    _LOGGER.error("Authentication error: %s", message)
+                    _LOGGER.error("Authentication error: %s", response_content)
                     raise AuthenticationError
                 if resp.status in [404, 405, 500]:
-                    _LOGGER.warning("%s", message)
+                    _LOGGER.warning("%s", response_content)
 
                 if (
                     method.lower() != "get"
-                    and isinstance(message, dict)
-                    and any(key in message for key in UPDATE_TRIGGERS)
+                    and isinstance(response_content, dict)
+                    and any(key in response_content for key in UPDATE_TRIGGERS)
                 ):
                     await self.update()
-                return message
+                return response_content
 
         except (TimeoutError, ServerTimeoutError):
             _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
@@ -170,7 +183,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
             _LOGGER.error("Content error: %s", err.message)
             raise
 
-    async def send_command(self, command: str) -> tuple:
+    async def send_command(self, command: str) -> tuple[Any, Any]:
         """Send a RAPI command to the charger and parses the response."""
         url = f"{self.url}r"
         data = {"json": 1, "rapi": command}
@@ -220,13 +233,13 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
                         "Received non-JSON response from /config: %s", response
                     )
 
-    async def test_and_get(self) -> dict:
+    async def test_and_get(self) -> dict[str, Any]:
         """Test connection.
 
         Return model serial number as dict
         """
         url = f"{self.url}config"
-        data = {}
+        data: dict[str, Any] = {}
 
         response = await self.process_request(url, method="get")
         if not isinstance(response, Mapping):
@@ -276,7 +289,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
 
         self._start_listening()
 
-    def _start_listening(self):
+    def _start_listening(self) -> None:
         """Start the websocket listener."""
         if not self._loop:
             try:
@@ -300,7 +313,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
                 )
                 self._loop_thread.start()
 
-    async def _update_status(self, msgtype, data, error):
+    async def _update_status(self, msgtype: str, data: Any, error: Any) -> None:
         """Update data from websocket listener."""
         if msgtype == SIGNAL_CONNECTION_STATE:
             uri = self.websocket.uri if self.websocket else "Unknown"
@@ -316,18 +329,18 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
                 self._ws_listening = False
 
             # Stopped websockets without errors are expected during shutdown
-            # and ignored
-            elif data == STATE_STOPPED and error:
-                _LOGGER.debug(
-                    "Websocket to %s failed, aborting [Error: %s]",
-                    uri,
-                    error,
-                )
+            elif data == STATE_STOPPED:
+                if error:
+                    _LOGGER.debug(
+                        "Websocket to %s failed, aborting [Error: %s]",
+                        uri,
+                        error,
+                    )
                 self._ws_listening = False
 
         elif msgtype == "data":
             _LOGGER.debug("Websocket data: %s", data)
-            if not isinstance(data, Mapping):
+            if not isinstance(data, MutableMapping):
                 _LOGGER.warning("Received non-Mapping websocket data: %s", data)
                 return
 
@@ -354,7 +367,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
                 if inspect.isawaitable(result):
                     await result
 
-    async def _shutdown(self):
+    async def _shutdown(self) -> None:
         """Shutdown the websocket and tasks on the listener loop."""
         tasks = []
         if self._ws_keepalive_task:
@@ -417,7 +430,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
             # Standard async disconnect for caller loop
             await self._shutdown()
 
-    def is_coroutine_function(self, callback):
+    def is_coroutine_function(self, callback: Any) -> bool:
         """Check if a callback is a coroutine function."""
         return inspect.iscoroutinefunction(callback)
 
@@ -428,7 +441,13 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
             return STATE_STOPPED
         return self.websocket.state
 
-    async def repeat(self, interval, func, *args, **kwargs):
+    async def repeat(
+        self,
+        interval: float,
+        func: Callable[..., Any],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
         """Run func every interval seconds.
 
         If func has not finished before *interval*, will run again
@@ -436,10 +455,12 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
 
         *args and **kwargs are passed as the arguments to func.
         """
-        while self.ws_state != STATE_STOPPED and self._ws_listening:
+        while self.ws_state != STATE_STOPPED:
             await asyncio.sleep(interval)
-            if self.ws_state == STATE_STOPPED or not self._ws_listening:
+            if self.ws_state == STATE_STOPPED:
                 break
+            if not self._ws_listening:
+                continue
             result = func(*args, **kwargs)
             if inspect.isawaitable(result):
                 await result

openevsehttp/commands.py

@@ -7,7 +7,7 @@ import logging
 from collections.abc import Mapping
 from typing import Any
 
-import aiohttp  # type: ignore
+import aiohttp
 from aiohttp.client_exceptions import ContentTypeError, ServerTimeoutError
 from awesomeversion import AwesomeVersion
 from awesomeversion.exceptions import AwesomeVersionCompareException
@@ -23,8 +23,8 @@ class CommandsMixin:
     """Mixin providing command methods for OpenEVSE."""
 
     url: str
-    _status: dict
-    _config: dict
+    _status: dict[str, Any]
+    _config: dict[str, Any]
     _session: Any
 
     # These are defined in client.py
@@ -33,10 +33,10 @@ class CommandsMixin:
 
     async def process_request(
         self, url: str, method: str = "", data: Any = None, rapi: Any = None
-    ) -> Mapping[str, Any] | list[Any] | str:
+    ) -> Mapping[str, Any] | list[Any] | str | bool:
         raise NotImplementedError
 
-    async def send_command(self, command: str) -> tuple:
+    async def send_command(self, command: str) -> tuple[Any, Any]:
         raise NotImplementedError
 
     async def update(self, force_status: bool = False) -> None:
@@ -382,7 +382,7 @@ class CommandsMixin:
         _LOGGER.debug("EVSE Restart response: %s", response)
 
     # Firmware version
-    async def firmware_check(self) -> dict | None:
+    async def firmware_check(self) -> dict[str, Any] | None:
         """Return the latest firmware version."""
         if "version" not in self._config:
             # Throw warning if we can't find the version
@@ -426,7 +426,7 @@ class CommandsMixin:
 
     async def _firmware_check_with_session(
         self, session: aiohttp.ClientSession, url: str, method: str
-    ) -> dict | None:
+    ) -> dict[str, Any] | None:
         """Process a firmware check request with a given session."""
         http_method = getattr(session, method)
         _LOGGER.debug(
@@ -504,7 +504,7 @@ class CommandsMixin:
         firmware_url: str | None = None,
         firmware_bytes: bytes | None = None,
         filename: str = "firmware.bin",
-    ) -> Mapping[str, Any] | list[Any] | str:
+    ) -> Mapping[str, Any] | list[Any] | str | bool:
         """Instruct the device to update its firmware.
 
         You can either:

openevsehttp/managers.py

@@ -23,7 +23,7 @@ class ManagersMixin:
 
     async def process_request(
         self, url: str, method: str = "", data: Any = None, rapi: Any = None
-    ) -> Mapping[str, Any] | list[Any] | str:
+    ) -> Mapping[str, Any] | list[Any] | str | bool:
         raise NotImplementedError
 
     def _normalize_response(self, response: Any) -> dict[str, Any] | list[Any]:

openevsehttp/properties.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 from collections.abc import Mapping
 from datetime import datetime, timedelta, timezone
-from typing import Any
+from typing import Any, cast
 
 from .const import MAX_AMPS, MIN_AMPS, states
 from .exceptions import UnsupportedFeature
@@ -17,8 +17,8 @@ _LOGGER = logging.getLogger(__name__)
 class PropertiesMixin:
     """Mixin providing all @property accessors for OpenEVSE."""
 
-    _status: dict
-    _config: dict
+    _status: dict[str, Any]
+    _config: dict[str, Any]
 
     # These are used by properties but defined in client.py
     def _version_check(self, min_version: str, max_version: str = "") -> bool:
@@ -125,15 +125,15 @@ class PropertiesMixin:
     @property
     def max_current(self) -> int | None:
         """Return the max current."""
-        return self._status.get("max_current", None)
+        return cast(int | None, self._status.get("max_current", None))
 
     @property
     def wifi_firmware(self) -> str | None:
         """Return the ESP firmware version."""
         value = self._config.get("version")
-        if value is not None:
-            value = normalize_version(value)
-        return value
+        if value is None:
+            return None
+        return normalize_version(value)
 
     @property
     def ip_address(self) -> str | None:
@@ -303,27 +303,30 @@ class PropertiesMixin:
     @property
     def total_day(self) -> float | None:
         """Get the total day energy usage."""
-        return self._status.get("total_day", None)
+        return cast(float | None, self._status.get("total_day", None))
 
     @property
     def total_week(self) -> float | None:
         """Get the total week energy usage."""
-        return self._status.get("total_week", None)
+        return cast(float | None, self._status.get("total_week", None))
 
     @property
     def total_month(self) -> float | None:
         """Get the total month energy usage."""
-        return self._status.get("total_month", None)
+        return cast(float | None, self._status.get("total_month", None))
 
     @property
     def total_year(self) -> float | None:
         """Get the total year energy usage."""
-        return self._status.get("total_year", None)
+        return cast(float | None, self._status.get("total_year", None))
 
     @property
     def has_limit(self) -> bool | None:
         """Return if a limit has been set."""
-        return self._status.get("has_limit", self._status.get("limit", None))
+        return cast(
+            "bool | None",
+            self._status.get("has_limit", self._status.get("limit", None)),
+        )
 
     @property
     def protocol_version(self) -> str | None:
@@ -336,7 +339,7 @@ class PropertiesMixin:
     @property
     def vehicle(self) -> bool:
         """Return if a vehicle is connected to the EVSE."""
-        return self._status.get("vehicle", False)
+        return bool(self._status.get("vehicle", False))
 
     @property
     def ota_update(self) -> bool:
@@ -356,7 +359,7 @@ class PropertiesMixin:
     @property
     def manual_override(self) -> bool:
         """Return if Manual Override is set."""
-        return self._status.get("manual_override", False)
+        return bool(self._status.get("manual_override", False))
 
     @property
     def divertmode(self) -> str:
@@ -394,7 +397,7 @@ class PropertiesMixin:
     @property
     def wifi_serial(self) -> str | None:
         """Return wifi serial."""
-        return self._config.get("wifi_serial", None)
+        return cast(str | None, self._config.get("wifi_serial", None))
 
     @property
     def charging_power(self) -> float | None:
@@ -415,12 +418,12 @@ class PropertiesMixin:
     @property
     def shaper_active(self) -> bool | None:
         """Return if shaper is active."""
-        return self._status.get("shaper", None)
+        return cast(bool | None, self._status.get("shaper", None))
 
     @property
     def shaper_live_power(self) -> int | None:
         """Return shaper live power reading."""
-        return self._status.get("shaper_live_pwr", None)
+        return cast(int | None, self._status.get("shaper_live_pwr", None))
 
     @property
     def shaper_available_current(self) -> float | None:
@@ -433,7 +436,7 @@ class PropertiesMixin:
     @property
     def shaper_max_power(self) -> int | None:
         """Return shaper live power reading."""
-        return self._status.get("shaper_max_pwr", None)
+        return cast(int | None, self._status.get("shaper_max_pwr", None))
 
     @property
     def shaper_updated(self) -> bool:
@@ -444,13 +447,17 @@ class PropertiesMixin:
     @property
     def vehicle_soc(self) -> int | None:
         """Return battery level."""
-        return self._status.get("vehicle_soc", self._status.get("battery_level", None))
+        return cast(
+            "int | None",
+            self._status.get("vehicle_soc", self._status.get("battery_level", None)),
+        )
 
     @property
     def vehicle_range(self) -> int | None:
         """Return battery range."""
-        return self._status.get(
-            "vehicle_range", self._status.get("battery_range", None)
+        return cast(
+            "int | None",
+            self._status.get("vehicle_range", self._status.get("battery_range", None)),
         )
 
     @property
@@ -472,12 +479,12 @@ class PropertiesMixin:
     @property
     def min_amps(self) -> int:
         """Return the minimum amps."""
-        return self._config.get("min_current_hard", MIN_AMPS)
+        return int(self._config.get("min_current_hard", MIN_AMPS))
 
     @property
     def max_amps(self) -> int:
         """Return the maximum amps."""
-        return self._config.get("max_current_hard", MAX_AMPS)
+        return int(self._config.get("max_current_hard", MAX_AMPS))
 
     @property
     def mqtt_connected(self) -> bool:
@@ -487,29 +494,29 @@ class PropertiesMixin:
     @property
     def emoncms_connected(self) -> bool | None:
         """Return the status of the emoncms connection."""
-        return self._status.get("emoncms_connected", None)
+        return cast(bool | None, self._status.get("emoncms_connected", None))
 
     @property
     def ocpp_connected(self) -> bool | None:
         """Return the status of the ocpp connection."""
-        return self._status.get("ocpp_connected", None)
+        return cast(bool | None, self._status.get("ocpp_connected", None))
 
     @property
     def uptime(self) -> int | None:
         """Return the unit uptime."""
-        return self._status.get("uptime", None)
+        return cast(int | None, self._status.get("uptime", None))
 
     @property
     def freeram(self) -> int | None:
         """Return the unit freeram."""
-        return self._status.get("freeram", None)
+        return cast(int | None, self._status.get("freeram", None))
 
     # Safety counts
     @property
-    def checks_count(self) -> dict:
+    def checks_count(self) -> dict[str, Any]:
         """Return the safety checks counts."""
         attributes = ("gfcicount", "nogndcount", "stuckcount")
-        counts = {}
+        counts: dict[str, Any] = {}
         if self._status is not None and set(attributes).issubset(self._status.keys()):
             counts["gfcicount"] = self._status["gfcicount"]
             counts["nogndcount"] = self._status["nogndcount"]
@@ -534,4 +541,4 @@ class PropertiesMixin:
         if not self._version_check("4.2.2"):
             _LOGGER.debug("Feature not supported for older firmware.")
             raise UnsupportedFeature
-        return self._status.get("power", 0)
+        return int(self._status.get("power", 0))

openevsehttp/sensors.py

@@ -23,7 +23,7 @@ class SensorsMixin:
 
     async def process_request(
         self, url: str, method: str = "", data: Any = None, rapi: Any = None
-    ) -> Mapping[str, Any] | list[Any] | str:
+    ) -> Mapping[str, Any] | list[Any] | str | bool:
         raise NotImplementedError
 
     def _normalize_response(self, response: Any) -> dict[str, Any] | list[Any]:

openevsehttp/websocket.py

@@ -1,9 +1,13 @@
 """Websocket class for OpenEVSE HTTP."""
 
+from __future__ import annotations
+
 import asyncio
 import datetime
 import inspect
 import logging
+from collections.abc import Awaitable, Callable
+from typing import Any
 
 import aiohttp
 
@@ -28,12 +32,12 @@ class OpenEVSEWebsocket:
 
     def __init__(
         self,
-        server,
-        callback,
-        user=None,
-        password=None,
+        server: str,
+        callback: Callable[[str, Any, Any], Any] | None,
+        user: str | None = None,
+        password: str | None = None,
         session: aiohttp.ClientSession | None = None,
-    ):
+    ) -> None:
         """Initialize a OpenEVSEWebsocket instance."""
         self.session = session
         self._session_external = session is not None
@@ -43,20 +47,20 @@ class OpenEVSEWebsocket:
         self.callback = callback
         self._state = STATE_DISCONNECTED
         self.failed_attempts = 0
-        self._error_reason = None
-        self._client = None
-        self._ping = None
-        self._pong = None
-        self._tasks: set[asyncio.Task] = set()
+        self._error_reason: Any = None
+        self._client: aiohttp.ClientWebSocketResponse | None = None
+        self._ping: datetime.datetime | None = None
+        self._pong: datetime.datetime | None = None
+        self._tasks: set[asyncio.Task[Any]] = set()
         self._listener_loop: asyncio.AbstractEventLoop | None = None
 
     @property
-    def state(self):
+    def state(self) -> str:
         """Return the current state."""
         return self._state
 
     @state.setter
-    def state(self, value):
+    def state(self, value: str) -> None:
         """Setter that schedules the callback."""
         self._state = value
         _LOGGER.debug("Websocket %s", value)
@@ -76,21 +80,16 @@ class OpenEVSEWebsocket:
             if self._listener_loop:
                 self._listener_loop.call_soon_threadsafe(self._schedule_task, coro)
             else:
-                try:
-                    task = asyncio.ensure_future(coro)
-                    self._tasks.add(task)
-                    task.add_done_callback(self._tasks.discard)
-                except RuntimeError:
-                    # Fallback to get_event_loop if ensure_future fails and no _listener_loop
-                    loop = asyncio.get_event_loop()
-                    loop.call_soon_threadsafe(self._schedule_task, coro)
+                task = asyncio.ensure_future(coro)
+                self._tasks.add(task)
+                task.add_done_callback(self._tasks.discard)
         except RuntimeError:
             _LOGGER.error("Failed to schedule callback from sync context: %s", coro)
             if hasattr(coro, "close"):
                 coro.close()
         self._error_reason = None
 
-    def _schedule_task(self, coro):
+    def _schedule_task(self, coro: Awaitable[Any]) -> None:
         """Schedule a task from a thread-safe context."""
         try:
             task = asyncio.ensure_future(coro)
@@ -103,7 +102,7 @@ class OpenEVSEWebsocket:
             if hasattr(coro, "close"):
                 coro.close()
 
-    async def _set_state(self, value):
+    async def _set_state(self, value: str) -> None:
         """Async helper to set the state and await the callback."""
         self._state = value
         _LOGGER.debug("Websocket %s", value)
@@ -114,11 +113,11 @@ class OpenEVSEWebsocket:
         self._error_reason = None
 
     @staticmethod
-    def _get_uri(server):
+    def _get_uri(server: str) -> str:
         """Generate the websocket URI."""
         return server[: server.rfind("/")].replace("http", "ws") + "/ws"
 
-    async def running(self):
+    async def running(self) -> None:
         """Open a persistent websocket connection and act on events."""
         await self._ensure_session()
         await self._set_state(STATE_STARTING)
@@ -128,6 +127,8 @@ class OpenEVSEWebsocket:
             auth = aiohttp.BasicAuth(self._user, self._password)
 
         try:
+            # Narrow type for mypy since _ensure_session sets self.session
+            assert self.session is not None
             async with self.session.ws_connect(
                 self.uri,
                 heartbeat=15,
@@ -156,7 +157,9 @@ class OpenEVSEWebsocket:
                 await self._client.close()
                 self._client = None
 
-    async def _handle_messages(self, ws_client):
+    async def _handle_messages(
+        self, ws_client: aiohttp.ClientWebSocketResponse
+    ) -> None:
         """Handle incoming websocket messages."""
         async for message in ws_client:
             if self.state == STATE_STOPPED:
@@ -183,7 +186,7 @@ class OpenEVSEWebsocket:
                     _LOGGER.error("Websocket error")
                 break
 
-    async def _handle_response_error(self, error):
+    async def _handle_response_error(self, error: aiohttp.ClientResponseError) -> None:
         """Handle ClientResponseError."""
         if error.status == 401:
             _LOGGER.error("Credentials rejected: %s", error)
@@ -193,7 +196,7 @@ class OpenEVSEWebsocket:
             self._error_reason = error
         await self._set_state(STATE_STOPPED)
 
-    async def _handle_connection_error(self, error):
+    async def _handle_connection_error(self, error: BaseException) -> None:
         """Handle connection errors."""
         self.failed_attempts += 1
         if self.failed_attempts > MAX_FAILED_ATTEMPTS:
@@ -209,7 +212,7 @@ class OpenEVSEWebsocket:
             await self._set_state(STATE_DISCONNECTED)
             await asyncio.sleep(retry_delay)
 
-    async def listen(self):
+    async def listen(self) -> None:
         """Start the listening websocket."""
         await self._ensure_session()
         self.failed_attempts = 0
@@ -220,13 +223,13 @@ class OpenEVSEWebsocket:
         finally:
             self._listener_loop = None
 
-    async def _ensure_session(self):
+    async def _ensure_session(self) -> None:
         """Ensure aiohttp.ClientSession exists."""
         if self.session is None:
             self.session = aiohttp.ClientSession()
             self._session_external = False
 
-    async def close(self):
+    async def close(self) -> None:
         """Close the listening websocket."""
         await self._set_state(STATE_STOPPED)
 
@@ -244,7 +247,7 @@ class OpenEVSEWebsocket:
             await self.session.close()
             self.session = None
 
-    async def keepalive(self):
+    async def keepalive(self) -> None:
         """Send ping requests to websocket."""
         if self._ping and self._pong:
             time_delta = self._pong - self._ping

{python_openevse_http-0.4.3.dist-info → python_openevse_http-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 0.4.3
+Version: 0.4.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
@@ -97,7 +97,7 @@ if __name__ == "__main__":
 | `/config` | GET, POST | ✅ | System and WiFi configuration |
 | `/override` | GET, POST, PATCH, DELETE | ✅ | Manual charging overrides & current limits |
 | `/claims` | GET, POST, DELETE | ✅ | Client-based charging claims |
-| `/schedule` | GET, POST | ✅ | Charging schedule management |
+| `/schedule` | GET, POST | ⚠️ | Charging schedule management (Retrieval only) |
 | `/limit` | GET, POST, DELETE | ✅ | Charge limits (Time, Energy, SoC) |
 | `/shaper` | POST | ✅ | Grid shaper control (v4.0.0+) |
 | `/restart` | POST | ✅ | Reboot WiFi gateway or EVSE module |
@@ -111,7 +111,7 @@ if __name__ == "__main__":
 | `/tesla` | GET | ❌ | Tesla vehicle integration |
 | `/certificates`| GET, POST, DELETE | ❌ | SSL/TLS certificate management |
 | `/schedule/plan`| GET | ❌ | Schedule planning and optimization |
-| `/update` | POST | ❌ | Firmware update interface |
+| `/update` | POST | ✅ | Firmware update interface |
 | `/rfid/add` | POST | ❌ | RFID tag management |
 
 ✅ = Fully Supported \| ⚠️ = Partial Support \| ❌ = Not yet implemented

python_openevse_http-0.4.4.dist-info/RECORD

@@ -0,0 +1,17 @@
+openevsehttp/__init__.py,sha256=I6a1mjOZHYiWb_qfCuDuFLOOncrkkB_7uwybtOIujfY,1165
+openevsehttp/__main__.py,sha256=EHmSdT7GjAVvHQxvLBTjZXsj_V5SB6B2_kpgUAT7mPM,146
+openevsehttp/client.py,sha256=8wd56AXEkEanRFWUPkmSDPUY8Zr7oHuNpg3_89m9iAM,18998
+openevsehttp/commands.py,sha256=X40x1UaXVfPEiquw7mJGSVA3AbO9gQ4Ay0TLm9i1Iqk,27264
+openevsehttp/const.py,sha256=y-2hGv_PCal_-VCSGC7IIyzQYtfeVdq3MjOhBWIdZvc,1440
+openevsehttp/exceptions.py,sha256=bqz-tHTW1AYJMKcm0s5M6z5tA6XZgjnCiBLW1XrZ_70,672
+openevsehttp/managers.py,sha256=EtQMQziwhoZeqKe2zWY-0yS7zedhuYjYtL5j9xBBCZ0,5380
+openevsehttp/properties.py,sha256=psGGiRacHYs1YYmagiWSlpfua-SnpU2nCviEYDZX0V8,17892
+openevsehttp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openevsehttp/sensors.py,sha256=yO4Q1sgJkvmfOi5dpoTwEoldsrpqgGz0k9fC7mFWass,4680
+openevsehttp/utils.py,sha256=e3HH_jwZgb1iBWJgIoMOM0JPrQNwXyVdOx5vTWOh4T0,858
+openevsehttp/websocket.py,sha256=TIMWzkRDs_9EUm3HAOaLWmZEX72BqHPhfDb9aIkz3uY,10409
+python_openevse_http-0.4.4.dist-info/licenses/LICENSE,sha256=hSB6TOQ7rmwSGb6XzqRjDGMvmUj5_GlacqQin3tegtA,11341
+python_openevse_http-0.4.4.dist-info/METADATA,sha256=RNnswPvgDpWIY5ehHia-XDxl4EGhZe1yIRquF0ZQP8M,4383
+python_openevse_http-0.4.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_openevse_http-0.4.4.dist-info/top_level.txt,sha256=u8RUkoEIE33Cjn6gmqiEoVpZ0VZ59WJ3FXBwwOg0CPE,13
+python_openevse_http-0.4.4.dist-info/RECORD,,

python_openevse_http-0.4.3.dist-info/RECORD

@@ -1,16 +0,0 @@
-openevsehttp/__init__.py,sha256=I6a1mjOZHYiWb_qfCuDuFLOOncrkkB_7uwybtOIujfY,1165
-openevsehttp/__main__.py,sha256=EHmSdT7GjAVvHQxvLBTjZXsj_V5SB6B2_kpgUAT7mPM,146
-openevsehttp/client.py,sha256=2SGL0RKZp08t_hGXHKIIRGk8wyrNJRcSXQE7nc0P9UU,17951
-openevsehttp/commands.py,sha256=vZFzNFg6-DqbpavTulypXOGCDwPChvBzoxIHXBlJrBc,27216
-openevsehttp/const.py,sha256=y-2hGv_PCal_-VCSGC7IIyzQYtfeVdq3MjOhBWIdZvc,1440
-openevsehttp/exceptions.py,sha256=bqz-tHTW1AYJMKcm0s5M6z5tA6XZgjnCiBLW1XrZ_70,672
-openevsehttp/managers.py,sha256=kEX1ZD9u-FY0UEZJsxeFEGBSGzSlkbBc0kmxCiMJtJw,5373
-openevsehttp/properties.py,sha256=9fmJo6xU8im-Dd2QoH8f2E-0veD8uL1QQYiaERvIRr8,17430
-openevsehttp/sensors.py,sha256=sJP2FPnU1Lk5S3VUyFT14JM1nKEBQPsjl-DiZI-pZrs,4673
-openevsehttp/utils.py,sha256=e3HH_jwZgb1iBWJgIoMOM0JPrQNwXyVdOx5vTWOh4T0,858
-openevsehttp/websocket.py,sha256=Mi_WFmlT3-9i6bbHIN6ua09SD8CpIle2vRXB3HyWzmM,10066
-python_openevse_http-0.4.3.dist-info/licenses/LICENSE,sha256=hSB6TOQ7rmwSGb6XzqRjDGMvmUj5_GlacqQin3tegtA,11341
-python_openevse_http-0.4.3.dist-info/METADATA,sha256=ThGhSK3mu1cGbRBLb4a5El7qhUNERBu6rC9tjdiHd20,4363
-python_openevse_http-0.4.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-python_openevse_http-0.4.3.dist-info/top_level.txt,sha256=u8RUkoEIE33Cjn6gmqiEoVpZ0VZ59WJ3FXBwwOg0CPE,13
-python_openevse_http-0.4.3.dist-info/RECORD,,