python-openevse-http 0.4.3__tar.gz → 1.0.0__tar.gz

{python_openevse_http-0.4.3 → python_openevse_http-1.0.0}/.github/workflows/autolabeler.yml

@@ -6,11 +6,13 @@ on:
       - opened
       - synchronize
       - reopened
+      - edited
   pull_request_target:
     types:
       - opened
       - synchronize
       - reopened
+      - edited
 
 permissions: {}
 

python_openevse_http-1.0.0/EXTERNAL_SESSION.md

@@ -0,0 +1,91 @@
+# HTTP Session Management
+
+## Overview
+
+The `python-openevse-http` library requires you to pass an external `aiohttp.ClientSession` to `OpenEVSE`. Session ownership stays with the caller, so the library no longer constructs temporary HTTP clients internally.
+
+## Benefits
+
+- **Session Reuse**: Share a single session across multiple OpenEVSE instances or other `aiohttp` clients
+- **Custom Configuration**: Configure timeouts, connectors, proxies, and SSL behavior yourself
+- **Resource Management**: Keep connection pooling and cleanup in one place
+- **Predictable Lifecycle**: Avoid hidden session creation inside request and websocket code paths
+
+## Usage
+
+### Basic Usage
+
+```python
+import aiohttp
+from openevsehttp import OpenEVSE
+
+async def main():
+    timeout = aiohttp.ClientTimeout(total=30)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        charger = OpenEVSE("openevse.local", session=session)
+        await charger.update()
+        print(f"Status: {charger.status}")
+        await charger.ws_disconnect()
+```
+
+### Sharing a Session
+
+```python
+import aiohttp
+from openevsehttp import OpenEVSE
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        charger1 = OpenEVSE("charger1.local", session=session)
+        charger2 = OpenEVSE("charger2.local", session=session)
+
+        await charger1.update()
+        await charger2.update()
+```
+
+### Websocket Startup
+
+Start websocket listening from the same event loop that owns the
+`aiohttp.ClientSession`:
+
+```python
+import aiohttp
+from openevsehttp import OpenEVSE
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        charger = OpenEVSE("openevse.local", session=session)
+        await charger.ws_start()
+        await charger.ws_disconnect()
+```
+
+`ws_start()` is async so websocket tasks are created on the event loop that owns
+the configured `aiohttp.ClientSession`. This prevents using a session from a
+private background loop it was not created on.
+
+## API Notes
+
+- `OpenEVSE(..., session=session)` uses the provided session for HTTP requests.
+- `OpenEVSEWebsocket(..., session=session)` uses the provided session for websocket connections.
+- If no session is configured, HTTP requests and websocket startup raise `RuntimeError`.
+- Call `await charger.ws_start()` from the event loop that owns the session.
+- Externally provided sessions are never closed by the library.
+
+## Migration
+
+Before:
+
+```python
+charger = OpenEVSE("openevse.local")
+await charger.update()
+```
+
+After:
+
+```python
+import aiohttp
+
+async with aiohttp.ClientSession() as session:
+    charger = OpenEVSE("openevse.local", session=session)
+    await charger.update()
+```

{python_openevse_http-0.4.3/python_openevse_http.egg-info → python_openevse_http-1.0.0}/PKG-INFO

@@ -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-0.4.3 → python_openevse_http-1.0.0}/README.md

@@ -29,28 +29,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())
@@ -64,7 +60,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 |
@@ -78,7 +74,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.3 → python_openevse_http-1.0.0}/example_external_session.py

@@ -31,19 +31,6 @@ async def example_with_external_session():
         await charger.ws_disconnect()
 
 
-async def example_without_external_session():
-    """Demonstrate without external session (backward compatible)."""
-    # The library will create and manage its own sessions
-    charger = OpenEVSE("openevse.local")
-
-    # Use the charger normally
-    await charger.update()
-    print(f"Status: {charger.status}")
-    print(f"Current: {charger.charging_current}A")
-
-    await charger.ws_disconnect()
-
-
 async def example_shared_session():
     """Demonstrate sharing a session between multiple clients."""
     async with aiohttp.ClientSession() as session:

{python_openevse_http-0.4.3 → python_openevse_http-1.0.0}/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

{python_openevse_http-0.4.3 → python_openevse_http-1.0.0}/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: