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

openevsehttp/client.py

@@ -7,16 +7,18 @@ 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
 
 from .commands import CommandsMixin
 from .const import (
+    ERROR_SESSION_LOOP_MISMATCH,
+    ERROR_SESSION_REQUIRED,
     ERROR_TIMEOUT,
     UPDATE_TRIGGERS,
 )
@@ -56,19 +58,29 @@ 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
-        self._session_external = session is not None
+
+    def _get_session(self) -> aiohttp.ClientSession:
+        """Return the configured HTTP session or fail fast."""
+        if self._session is None:
+            raise RuntimeError(ERROR_SESSION_REQUIRED)
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return self._session
+        self._validate_session_loop(loop)
+        return self._session
 
     async def process_request(
         self,
@@ -76,7 +88,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"]
@@ -86,16 +98,10 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
         if self._user and self._pwd:
             auth = aiohttp.BasicAuth(self._user, self._pwd)
 
-        # Use provided session or create a temporary one
-        if (session := self._session) is None:
-            async with aiohttp.ClientSession() as session:
-                return await self._process_request_with_session(
-                    session, url, method, data, rapi, auth
-                )
-        else:
-            return await self._process_request_with_session(
-                session, url, method, data, rapi, auth
-            )
+        session = self._get_session()
+        return await self._process_request_with_session(
+            session, url, method, data, rapi, auth
+        )
 
     def _normalize_response(self, response: Any) -> dict[str, Any] | list[Any]:
         """Normalize response to a dict or list."""
@@ -112,7 +118,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 +136,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 +189,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 +239,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):
@@ -246,37 +265,38 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
         data = {"serial": serial, "model": model}
         return data
 
-    def ws_start(self) -> None:
+    async def ws_start(self) -> None:
         """Start the websocket listener."""
         if self.websocket and self.websocket.state != STATE_STOPPED:
             raise AlreadyListening
 
-        # Detect loop mismatch
-        use_session = self._session
-        try:
-            asyncio.get_running_loop()
-        except RuntimeError:
-            # We are about to create a private loop in _start_listening
-            # If we have a session, it's likely bound to another loop
-            if self._session:
-                _LOGGER.warning(
-                    "Caller-provided session may not work on private event loop. "
-                    "Creating a loop-local session."
-                )
-                use_session = None
-                # Clear self._session so subsequent await self.update() uses
-                # a loop-local session as well.
-                self._session = None
-                self._session_external = False
+        self._get_session()
 
         if not self.websocket or self.websocket.state == STATE_STOPPED:
-            self.websocket = OpenEVSEWebsocket(
-                self.url, self._update_status, self._user, self._pwd, use_session
-            )
+            self._create_websocket()
 
         self._start_listening()
 
-    def _start_listening(self):
+    def _create_websocket(self) -> None:
+        """Create a websocket using the configured session."""
+        self.websocket = OpenEVSEWebsocket(
+            self.url,
+            self._update_status,
+            self._user,
+            self._pwd,
+            self._session,
+        )
+
+    def _validate_session_loop(self, loop: asyncio.AbstractEventLoop) -> None:
+        """Ensure the configured session belongs to the active event loop."""
+        session_loop = getattr(self._session, "_loop", None)
+        if (
+            isinstance(session_loop, asyncio.AbstractEventLoop)
+            and session_loop is not loop
+        ):
+            raise RuntimeError(ERROR_SESSION_LOOP_MISMATCH)
+
+    def _start_listening(self) -> None:
         """Start the websocket listener."""
         if not self._loop:
             try:
@@ -300,7 +320,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 +336,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 +374,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 +437,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 +448,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 +462,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,9 +23,9 @@ class CommandsMixin:
     """Mixin providing command methods for OpenEVSE."""
 
     url: str
-    _status: dict
-    _config: dict
-    _session: Any
+    _status: dict[str, Any]
+    _config: dict[str, Any]
+    _session: aiohttp.ClientSession | None
 
     # These are defined in client.py
     def _version_check(self, min_version: str, max_version: str = "") -> bool:
@@ -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:
@@ -46,6 +46,10 @@ class CommandsMixin:
         """Normalize response to a dict or list."""
         raise NotImplementedError
 
+    def _get_session(self) -> aiohttp.ClientSession:
+        """Return the configured HTTP session."""
+        raise NotImplementedError
+
     def _flag_ota_if_started(self, response: Any) -> None:
         """Flag OTA as active if response indicates firmware update has started."""
         normalized = self._normalize_response(response)
@@ -382,7 +386,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
@@ -409,12 +413,8 @@ class CommandsMixin:
             return None
 
         try:
-            if (session := self._session) is None:
-                async with aiohttp.ClientSession() as session:
-                    return await self._firmware_check_with_session(session, url, method)
-            else:
-                return await self._firmware_check_with_session(session, url, method)
-
+            session = self._get_session()
+            return await self._firmware_check_with_session(session, url, method)
         except (TimeoutError, ServerTimeoutError):
             _LOGGER.error("%s: %s", "Timeout while updating", url)
         except ContentTypeError as err:
@@ -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/const.py

@@ -62,3 +62,10 @@ RAPI_ERRORS = [
 ]
 
 SUCCESS_ANSWERS = ["OK", "done", "no change", "Created", "Updated", "Deleted"]
+
+ERROR_SESSION_REQUIRED = (
+    "An aiohttp.ClientSession must be provided via the session argument."
+)
+ERROR_SESSION_LOOP_MISMATCH = (
+    "The aiohttp.ClientSession is bound to a different event loop."
+)

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,12 +1,21 @@
 """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
 
+from .const import (
+    ERROR_SESSION_LOOP_MISMATCH,
+    ERROR_SESSION_REQUIRED,
+)
+
 _LOGGER = logging.getLogger(__name__)
 
 MAX_FAILED_ATTEMPTS = 5
@@ -28,35 +37,34 @@ 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
         self.uri = self._get_uri(server)
         self._user = user
         self._password = password
         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 +84,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 +106,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 +117,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 +131,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 +161,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 +190,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 +200,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 +216,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 +227,20 @@ class OpenEVSEWebsocket:
         finally:
             self._listener_loop = None
 
-    async def _ensure_session(self):
-        """Ensure aiohttp.ClientSession exists."""
+    async def _ensure_session(self) -> None:
+        """Ensure an external aiohttp.ClientSession exists."""
         if self.session is None:
-            self.session = aiohttp.ClientSession()
-            self._session_external = False
+            raise RuntimeError(ERROR_SESSION_REQUIRED)
+
+        loop = asyncio.get_running_loop()
+        session_loop = getattr(self.session, "_loop", None)
+        if (
+            isinstance(session_loop, asyncio.AbstractEventLoop)
+            and session_loop is not loop
+        ):
+            raise RuntimeError(ERROR_SESSION_LOOP_MISMATCH)
 
-    async def close(self):
+    async def close(self) -> None:
         """Close the listening websocket."""
         await self._set_state(STATE_STOPPED)
 
@@ -239,12 +253,8 @@ class OpenEVSEWebsocket:
         if self._client is not None:
             await self._client.close()
             self._client = None
-        # Only close the session if we created it
-        if not self._session_external and self.session is not None:
-            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-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 0.4.3
+Version: 1.0.0
 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
@@ -62,28 +62,24 @@ pip install python_openevse_http
 
 ```python
 import asyncio
+import aiohttp
 from openevsehttp import OpenEVSE
 
 async def main():
-    # Initialize the charger
-    charger = OpenEVSE("192.168.1.30")
+    async with aiohttp.ClientSession() as session:
+        charger = OpenEVSE("192.168.1.30", session=session)
+        await charger.update()
 
-    # Update state
-    await charger.update()
+        print(f"Charger State: {charger.status}")
+        print(f"Current Charge: {charger.charge_current}A")
 
-    print(f"Charger State: {charger.status}")
-    print(f"Current Charge: {charger.charge_current}A")
+        if charger.shaper_active:
+            print("Shaper is active, disabling...")
+        else:
+            print("Shaper is inactive, enabling...")
 
-    # Toggle the Shaper feature
-    if charger.shaper_active:
-        print("Shaper is active, disabling...")
-    else:
-        print("Shaper is inactive, enabling...")
-
-    await charger.toggle_shaper()
-
-    # Clean up
-    await charger.close()
+        await charger.toggle_shaper()
+        await charger.ws_disconnect()
 
 if __name__ == "__main__":
     asyncio.run(main())
@@ -97,7 +93,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 +107,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-1.0.0.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=tw8MGwraUVn5ERbQCR6JRWEvMRc7KnUgJvf_0viOQHo,18983
+openevsehttp/commands.py,sha256=JGxjmGvE2-eUJ1gD76y_701Qk3Kzab-6XtGeaXXDSb0,27243
+openevsehttp/const.py,sha256=9jVzW4CZz7uP7VKbGQT4v0jNeP5PPC55tR-jnG11ODA,1646
+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=dOSemvm7CM5pFb9RaoJSTIM6Tf5xtWMLEBEccKlBUKI,10517
+python_openevse_http-1.0.0.dist-info/licenses/LICENSE,sha256=hSB6TOQ7rmwSGb6XzqRjDGMvmUj5_GlacqQin3tegtA,11341
+python_openevse_http-1.0.0.dist-info/METADATA,sha256=fYgJfqxD6zmc8b540T6jStiE1AKNUmkqSC2vmHHHRjo,4417
+python_openevse_http-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_openevse_http-1.0.0.dist-info/top_level.txt,sha256=u8RUkoEIE33Cjn6gmqiEoVpZ0VZ59WJ3FXBwwOg0CPE,13
+python_openevse_http-1.0.0.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,,