Allow for a external session.

Author: c00w

openevsehttp/__main__.py

@@ -84,11 +84,18 @@
 class OpenEVSE:
     """Represent an OpenEVSE charger."""
 
-    def __init__(self, host: str, user: str = "", pwd: str = "") -> None:
+    def __init__(
+        self,
+        host: str,
+        user: str = "",
+        pwd: str = "",
+        session: aiohttp.ClientSession | None = None,
+    ) -> None:
         """Connect to an OpenEVSE charger equipped with wifi or ethernet."""
         self._user = user
         self._pwd = pwd
         self.url = f"http://{host}/"
+        self._session = session
         self._status: dict = {}
         self._config: dict = {}
         self._override = None
@@ -98,6 +105,13 @@ def __init__(self, host: str, user: str = "", pwd: str = "") -> None:
         self._loop = None
         self.tasks = None
 
+    @property
+    def session(self) -> aiohttp.ClientSession:
+        """Return the aiohttp session, creating one if needed."""
+        if self._session is None:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
     async def process_request(
         self,
         url: str,
@@ -113,61 +127,57 @@ async def process_request(
         if self._user and self._pwd:
             auth = aiohttp.BasicAuth(self._user, self._pwd)
 
-        async with aiohttp.ClientSession() as session:
-            http_method = getattr(session, method)
-            _LOGGER.debug(
-                "Connecting to %s with data: %s rapi: %s using method %s",
+        http_method = getattr(self.session, method)
+        _LOGGER.debug(
+            "Connecting to %s with data: %s rapi: %s using method %s",
+            url,
+            data,
+            rapi,
+            method,
+        )
+        try:
+            async with http_method(
                 url,
-                data,
-                rapi,
-                method,
-            )
-            try:
-                async with http_method(
-                    url,
-                    data=rapi,
-                    json=data,
-                    auth=auth,
-                ) as resp:
-                    try:
-                        message = await resp.text()
-                    except UnicodeDecodeError:
-                        _LOGGER.debug("Decoding error")
-                        message = await resp.read()
-                        message = message.decode(errors="replace")
-
-                    try:
-                        message = json.loads(message)
-                    except ValueError:
-                        _LOGGER.warning("Non JSON response: %s", message)
-
-                    if resp.status == 400:
-                        index = ""
-                        if "msg" in message.keys():
-                            index = "msg"
-                        elif "error" in message.keys():
-                            index = "error"
-                        _LOGGER.error("Error 400: %s", message[index])
-                        raise ParseJSONError
-                    if resp.status == 401:
-                        _LOGGER.error("Authentication error: %s", message)
-                        raise AuthenticationError
-                    if resp.status in [404, 405, 500]:
-                        _LOGGER.warning("%s", message)
-
-                    if method == "post" and "config_version" in message:
-                        await self.update()
-                    return message
-
-            except (TimeoutError, ServerTimeoutError) as err:
-                _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
-                raise err
-            except ContentTypeError as err:
-                _LOGGER.error("Content error: %s", err.message)
-                raise err
-
-            await session.close()
-            return message
+                data=rapi,
+                json=data,
+                auth=auth,
+            ) as resp:
+                try:
+                    message = await resp.text()
+                except UnicodeDecodeError:
+                    _LOGGER.debug("Decoding error")
+                    message = await resp.read()
+                    message = message.decode(errors="replace")
+
+                try:
+                    message = json.loads(message)
+                except ValueError:
+                    _LOGGER.warning("Non JSON response: %s", message)
+
+                if resp.status == 400:
+                    index = ""
+                    if "msg" in message.keys():
+                        index = "msg"
+                    elif "error" in message.keys():
+                        index = "error"
+                    _LOGGER.error("Error 400: %s", message[index])
+                    raise ParseJSONError
+                if resp.status == 401:
+                    _LOGGER.error("Authentication error: %s", message)
+                    raise AuthenticationError
+                if resp.status in [404, 405, 500]:
+                    _LOGGER.warning("%s", message)
+
+                if method == "post" and "config_version" in message:
+                    await self.update()
+                return message
+
+        except (TimeoutError, ServerTimeoutError) as err:
+            _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
+            raise err
+        except ContentTypeError as err:
+            _LOGGER.error("Content error: %s", err.message)
+            raise err
 
     async def send_command(self, command: str) -> tuple:
         """Send a RAPI command to the charger and parses the response."""
@@ -204,7 +214,11 @@ async def update(self) -> None:
         if not self.websocket:
             # Start Websocket listening
             self.websocket = OpenEVSEWebsocket(
-                self.url, self._update_status, self._user, self._pwd
+                self.url,
+                self._update_status,
+                self._user,
+                self._pwd,
+                session=self.session,
             )
 
     async def test_and_get(self) -> dict:
@@ -573,23 +587,22 @@ async def firmware_check(self) -> dict | None:
             return None
 
         try:
-            async with aiohttp.ClientSession() as session:
-                http_method = getattr(session, method)
-                _LOGGER.debug(
-                    "Connecting to %s using method %s",
-                    url,
-                    method,
-                )
-                async with http_method(url) as resp:
-                    if resp.status != 200:
-                        return None
-                    message = await resp.text()
-                    message = json.loads(message)
-                    response = {}
-                    response["latest_version"] = message["tag_name"]
-                    response["release_notes"] = message["body"]
-                    response["release_url"] = message["html_url"]
-                    return response
+            http_method = getattr(self.session, method)
+            _LOGGER.debug(
+                "Connecting to %s using method %s",
+                url,
+                method,
+            )
+            async with http_method(url) as resp:
+                if resp.status != 200:
+                    return None
+                message = await resp.text()
+                message = json.loads(message)
+                response = {}
+                response["latest_version"] = message["tag_name"]
+                response["release_notes"] = message["body"]
+                response["release_url"] = message["html_url"]
+                return response
 
         except (TimeoutError, ServerTimeoutError):
             _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)

openevsehttp/websocket.py

@@ -31,9 +31,10 @@ def __init__(
         callback,
         user=None,
         password=None,
+        session=None,
     ):
         """Initialize a OpenEVSEWebsocket instance."""
-        self.session = aiohttp.ClientSession()
+        self._session = session
         self.uri = self._get_uri(server)
         self._user = user
         self._password = password
@@ -45,6 +46,13 @@ def __init__(
         self._ping = None
         self._pong = None
 
+    @property
+    def session(self):
+        """Return the aiohttp session, creating one if needed."""
+        if self._session is None:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
     @property
     def state(self):
         """Return the current state."""
@@ -141,7 +149,8 @@ async def listen(self):
     async def close(self):
         """Close the listening websocket."""
         await OpenEVSEWebsocket.state.fset(self, STATE_STOPPED)
-        await self.session.close()
+        if self._client:
+            await self._client.close()
 
     async def keepalive(self):
         """Send ping requests to websocket."""