python-openevse-http 0.2.3__tar.gz → 0.2.5__tar.gz

{python_openevse_http-0.2.3/python_openevse_http.egg-info → python_openevse_http-0.2.5}/PKG-INFO

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

{python_openevse_http-0.2.3 → python_openevse_http-0.2.5}/openevsehttp/__main__.py

@@ -3,10 +3,10 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime, timedelta, timezone
 import json
 import logging
 import re
+from datetime import datetime, timedelta, timezone
 from typing import Any, Callable, Dict, Union
 
 import aiohttp  # type: ignore
@@ -84,7 +84,13 @@ UPDATE_TRIGGERS = [
 class OpenEVSE:
     """Represent an OpenEVSE charger."""
 
-    def __init__(self, host: str, user: str = "", pwd: str = "") -> None:
+    def __init__(
+        self,
+        host: str,
+        user: str = "",
+        pwd: str = "",
+        session: aiohttp.ClientSession | None = None,
+    ) -> None:
         """Connect to an OpenEVSE charger equipped with wifi or ethernet."""
         self._user = user
         self._pwd = pwd
@@ -97,6 +103,8 @@ class OpenEVSE:
         self.callback: Callable | None = None
         self._loop = None
         self.tasks = None
+        self._session = session
+        self._session_external = session is not None
 
     async def process_request(
         self,
@@ -113,7 +121,9 @@ class OpenEVSE:
         if self._user and self._pwd:
             auth = aiohttp.BasicAuth(self._user, self._pwd)
 
-        async with aiohttp.ClientSession() as session:
+        # Use provided session or create a temporary one
+        if self._session is not None:
+            session = self._session
             http_method = getattr(session, method)
             _LOGGER.debug(
                 "Connecting to %s with data: %s rapi: %s using method %s",
@@ -165,9 +175,59 @@ class OpenEVSE:
             except ContentTypeError as err:
                 _LOGGER.error("Content error: %s", err.message)
                 raise err
-
-            await session.close()
-            return message
+        else:
+            async with aiohttp.ClientSession() as session:
+                http_method = getattr(session, method)
+                _LOGGER.debug(
+                    "Connecting to %s with data: %s rapi: %s using method %s",
+                    url,
+                    data,
+                    rapi,
+                    method,
+                )
+                try:
+                    async with http_method(
+                        url,
+                        data=rapi,
+                        json=data,
+                        auth=auth,
+                    ) as resp:
+                        try:
+                            message = await resp.text()
+                        except UnicodeDecodeError:
+                            _LOGGER.debug("Decoding error")
+                            message = await resp.read()
+                            message = message.decode(errors="replace")
+
+                        try:
+                            message = json.loads(message)
+                        except ValueError:
+                            _LOGGER.warning("Non JSON response: %s", message)
+
+                        if resp.status == 400:
+                            index = ""
+                            if "msg" in message.keys():
+                                index = "msg"
+                            elif "error" in message.keys():
+                                index = "error"
+                            _LOGGER.error("Error 400: %s", message[index])
+                            raise ParseJSONError
+                        if resp.status == 401:
+                            _LOGGER.error("Authentication error: %s", message)
+                            raise AuthenticationError
+                        if resp.status in [404, 405, 500]:
+                            _LOGGER.warning("%s", message)
+
+                        if method == "post" and "config_version" in message:
+                            await self.update()
+                        return message
+
+                except (TimeoutError, ServerTimeoutError) as err:
+                    _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
+                    raise err
+                except ContentTypeError as err:
+                    _LOGGER.error("Content error: %s", err.message)
+                    raise err
 
     async def send_command(self, command: str) -> tuple:
         """Send a RAPI command to the charger and parses the response."""
@@ -204,7 +264,7 @@ class OpenEVSE:
         if not self.websocket:
             # Start Websocket listening
             self.websocket = OpenEVSEWebsocket(
-                self.url, self._update_status, self._user, self._pwd
+                self.url, self._update_status, self._user, self._pwd, self._session
             )
 
     async def test_and_get(self) -> dict:
@@ -573,7 +633,8 @@ class OpenEVSE:
             return None
 
         try:
-            async with aiohttp.ClientSession() as session:
+            if self._session:
+                session = self._session
                 http_method = getattr(session, method)
                 _LOGGER.debug(
                     "Connecting to %s using method %s",
@@ -590,6 +651,24 @@ class OpenEVSE:
                     response["release_notes"] = message["body"]
                     response["release_url"] = message["html_url"]
                     return response
+            else:
+                async with aiohttp.ClientSession() as session:
+                    http_method = getattr(session, method)
+                    _LOGGER.debug(
+                        "Connecting to %s using method %s",
+                        url,
+                        method,
+                    )
+                    async with http_method(url) as resp:
+                        if resp.status != 200:
+                            return None
+                        message = await resp.text()
+                        message = json.loads(message)
+                        response = {}
+                        response["latest_version"] = message["tag_name"]
+                        response["release_notes"] = message["body"]
+                        response["release_url"] = message["html_url"]
+                        return response
 
         except (TimeoutError, ServerTimeoutError):
             _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
@@ -1233,6 +1312,20 @@ class OpenEVSE:
             return round(self._status["voltage"] * self._status["amp"], 2)
         return None
 
+    # Shaper HTTP Posting
+    async def set_shaper_live_pwr(self, power: int) -> None:
+        """Send pushed sensor data to shaper."""
+        if not self._version_check("4.0.0"):
+            _LOGGER.debug("Feature not supported for older firmware.")
+            raise UnsupportedFeature
+
+        url = f"{self.url}status"
+        data = {"shaper_live_pwr": power}
+
+        _LOGGER.debug("Posting shaper data: %s", data)
+        response = await self.process_request(url=url, method="post", data=data)
+        _LOGGER.debug("Shaper response: %s", response)
+
     # Shaper values
     @property
     def shaper_active(self) -> bool | None:

{python_openevse_http-0.2.3 → python_openevse_http-0.2.5}/openevsehttp/websocket.py

@@ -31,9 +31,11 @@ class OpenEVSEWebsocket:
         callback,
         user=None,
         password=None,
+        session: aiohttp.ClientSession | None = None,
     ):
         """Initialize a OpenEVSEWebsocket instance."""
-        self.session = aiohttp.ClientSession()
+        self.session = session if session is not None else aiohttp.ClientSession()
+        self._session_external = session is not None
         self.uri = self._get_uri(server)
         self._user = user
         self._password = password
@@ -51,8 +53,26 @@ class OpenEVSEWebsocket:
         return self._state
 
     @state.setter
-    async def state(self, value):
-        """Set the state."""
+    def state(self, value):
+        """Setter that schedules the callback."""
+        self._state = value
+        _LOGGER.debug("Websocket %s", value)
+        # Schedule the callback asynchronously without awaiting here.
+        try:
+            asyncio.create_task(
+                self.callback(SIGNAL_CONNECTION_STATE, value, self._error_reason)
+            )
+        except RuntimeError:
+            # If there's no running loop, schedule safely on the event loop.
+            loop = asyncio.get_event_loop()
+            loop.call_soon_threadsafe(
+                asyncio.create_task,
+                self.callback(SIGNAL_CONNECTION_STATE, value, self._error_reason),
+            )
+        self._error_reason = None
+
+    async def _set_state(self, value):
+        """Async helper to set the state and await the callback."""
         self._state = value
         _LOGGER.debug("Websocket %s", value)
         await self.callback(SIGNAL_CONNECTION_STATE, value, self._error_reason)
@@ -65,7 +85,7 @@ class OpenEVSEWebsocket:
 
     async def running(self):
         """Open a persistent websocket connection and act on events."""
-        await OpenEVSEWebsocket.state.fset(self, STATE_STARTING)
+        await self._set_state(STATE_STARTING)
         auth = None
 
         if self._user and self._password:
@@ -77,7 +97,7 @@ class OpenEVSEWebsocket:
                 heartbeat=15,
                 auth=auth,
             ) as ws_client:
-                await OpenEVSEWebsocket.state.fset(self, STATE_CONNECTED)
+                await self._set_state(STATE_CONNECTED)
                 self.failed_attempts = 0
                 self._client = ws_client
 
@@ -107,11 +127,11 @@ class OpenEVSEWebsocket:
             else:
                 _LOGGER.error("Unexpected response received: %s", error)
                 self._error_reason = error
-            await OpenEVSEWebsocket.state.fset(self, STATE_STOPPED)
+            await self._set_state(STATE_STOPPED)
         except (aiohttp.ClientConnectionError, asyncio.TimeoutError) as error:
             if self.failed_attempts > MAX_FAILED_ATTEMPTS:
                 self._error_reason = ERROR_TOO_MANY_RETRIES
-                await OpenEVSEWebsocket.state.fset(self, STATE_STOPPED)
+                await self._set_state(STATE_STOPPED)
             elif self.state != STATE_STOPPED:
                 retry_delay = min(2 ** (self.failed_attempts - 1) * 30, 300)
                 self.failed_attempts += 1
@@ -120,16 +140,16 @@ class OpenEVSEWebsocket:
                     retry_delay,
                     error,
                 )
-                await OpenEVSEWebsocket.state.fset(self, STATE_DISCONNECTED)
+                await self._set_state(STATE_DISCONNECTED)
                 await asyncio.sleep(retry_delay)
         except Exception as error:  # pylint: disable=broad-except
             if self.state != STATE_STOPPED:
                 _LOGGER.exception("Unexpected exception occurred: %s", error)
                 self._error_reason = error
-                await OpenEVSEWebsocket.state.fset(self, STATE_STOPPED)
+                await self._set_state(STATE_STOPPED)
         else:
             if self.state != STATE_STOPPED:
-                await OpenEVSEWebsocket.state.fset(self, STATE_DISCONNECTED)
+                await self._set_state(STATE_DISCONNECTED)
                 await asyncio.sleep(5)
 
     async def listen(self):
@@ -140,8 +160,10 @@ class OpenEVSEWebsocket:
 
     async def close(self):
         """Close the listening websocket."""
-        await OpenEVSEWebsocket.state.fset(self, STATE_STOPPED)
-        await self.session.close()
+        await self._set_state(STATE_STOPPED)
+        # Only close the session if we created it
+        if not self._session_external:
+            await self.session.close()
 
     async def keepalive(self):
         """Send ping requests to websocket."""
@@ -151,7 +173,7 @@ class OpenEVSEWebsocket:
                 # Negitive time should indicate no pong reply so consider the
                 # websocket disconnected.
                 self._error_reason = ERROR_PING_TIMEOUT
-                await OpenEVSEWebsocket.state.fset(self, STATE_DISCONNECTED)
+                await self._set_state(STATE_DISCONNECTED)
 
         data = {"ping": 1}
         _LOGGER.debug("Sending message: %s to websocket.", data)
@@ -168,7 +190,7 @@ class OpenEVSEWebsocket:
             _LOGGER.error("Error parsing data: %s", err)
         except RuntimeError as err:
             _LOGGER.debug("Websocket connection issue: %s", err)
-            await OpenEVSEWebsocket.state.fset(self, STATE_DISCONNECTED)
+            await self._set_state(STATE_DISCONNECTED)
         except Exception as err:  # pylint: disable=broad-exception-caught
             _LOGGER.debug("Problem sending ping request: %s", err)
-            await OpenEVSEWebsocket.state.fset(self, STATE_DISCONNECTED)
+            await self._set_state(STATE_DISCONNECTED)

{python_openevse_http-0.2.3 → python_openevse_http-0.2.5/python_openevse_http.egg-info}/PKG-INFO

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

{python_openevse_http-0.2.3 → python_openevse_http-0.2.5}/python_openevse_http.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ python_openevse_http.egg-info/dependency_links.txt
 python_openevse_http.egg-info/not-zip-safe
 python_openevse_http.egg-info/requires.txt
 python_openevse_http.egg-info/top_level.txt
+tests/test_external_session.py
 tests/test_main.py
 tests/test_main_edge_cases.py
 tests/test_websocket.py

{python_openevse_http-0.2.3 → python_openevse_http-0.2.5}/setup.py

@@ -6,7 +6,7 @@ from setuptools import find_packages, setup
 
 PROJECT_DIR = Path(__file__).parent.resolve()
 README_FILE = PROJECT_DIR / "README.md"
-VERSION = "0.2.3"
+VERSION = "0.2.5"
 
 setup(
     name="python_openevse_http",

python_openevse_http-0.2.5/tests/test_external_session.py

@@ -0,0 +1,199 @@
+"""Test external session management."""
+
+import json
+from unittest.mock import AsyncMock, MagicMock
+
+import aiohttp
+import pytest
+
+from openevsehttp.__main__ import OpenEVSE
+from tests.common import load_fixture
+
+pytestmark = pytest.mark.asyncio
+
+TEST_URL_STATUS = "http://openevse.test.tld/status"
+TEST_URL_CONFIG = "http://openevse.test.tld/config"
+TEST_TLD = "openevse.test.tld"
+
+
+async def test_external_session_provided():
+    """Test that an external session is used when provided."""
+    # Create a mock session
+    mock_session = MagicMock(spec=aiohttp.ClientSession)
+    mock_session.closed = False
+
+    # Mock the response
+    mock_response = AsyncMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value=load_fixture("v4_json/status.json"))
+
+    # Mock the get method to return the response
+    mock_get = AsyncMock(return_value=mock_response)
+    mock_get.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_get.__aexit__ = AsyncMock(return_value=None)
+    mock_session.get = MagicMock(return_value=mock_get)
+
+    # Create OpenEVSE instance with external session
+    charger = OpenEVSE(TEST_TLD, session=mock_session)
+
+    # Verify the session is stored
+    assert charger._session is mock_session
+    assert charger._session_external is True
+
+    # Make a request
+    await charger.process_request(TEST_URL_STATUS, method="get")
+
+    # Verify the external session was used
+    mock_session.get.assert_called_once()
+
+
+async def test_no_external_session(mock_aioclient):
+    """Test that a temporary session is created when none is provided."""
+    mock_aioclient.get(
+        TEST_URL_STATUS,
+        status=200,
+        body=load_fixture("v4_json/status.json"),
+    )
+
+    # Create OpenEVSE instance without external session
+    charger = OpenEVSE(TEST_TLD)
+
+    # Verify no session is stored
+    assert charger._session is None
+    assert charger._session_external is False
+
+    # Make a request - should create a temporary session
+    await charger.process_request(TEST_URL_STATUS, method="get")
+
+
+async def test_external_session_with_update(mock_aioclient):
+    """Test that external session is used during update."""
+    mock_aioclient.get(
+        TEST_URL_STATUS,
+        status=200,
+        body=load_fixture("v4_json/status.json"),
+    )
+    mock_aioclient.get(
+        TEST_URL_CONFIG,
+        status=200,
+        body=load_fixture("v4_json/config.json"),
+    )
+
+    # Create a real session for testing
+    async with aiohttp.ClientSession() as session:
+        # Create OpenEVSE instance with external session
+        charger = OpenEVSE(TEST_TLD, session=session)
+
+        # Verify the session is stored
+        assert charger._session is session
+        assert charger._session_external is True
+
+        # Update should use the external session
+        await charger.update()
+
+        # Verify status was updated
+        assert charger._status is not None
+        assert charger._config is not None
+
+
+async def test_websocket_uses_external_session(mock_aioclient):
+    """Test that websocket uses the external session."""
+    mock_aioclient.get(
+        TEST_URL_STATUS,
+        status=200,
+        body=load_fixture("v4_json/status.json"),
+    )
+    mock_aioclient.get(
+        TEST_URL_CONFIG,
+        status=200,
+        body=load_fixture("v4_json/config.json"),
+    )
+
+    # Create a real session for testing
+    async with aiohttp.ClientSession() as session:
+        # Create OpenEVSE instance with external session
+        charger = OpenEVSE(TEST_TLD, session=session)
+
+        # Update to initialize websocket
+        await charger.update()
+
+        # Verify websocket was created with the session
+        assert charger.websocket is not None
+        assert charger.websocket.session is session
+        assert charger.websocket._session_external is True
+
+        # Cleanup
+        await charger.ws_disconnect()
+
+
+async def test_firmware_check_with_external_session(mock_aioclient):
+    """Test that firmware_check uses external session."""
+    mock_aioclient.get(
+        TEST_URL_STATUS,
+        status=200,
+        body=load_fixture("v4_json/status.json"),
+    )
+    mock_aioclient.get(
+        TEST_URL_CONFIG,
+        status=200,
+        body=load_fixture("v4_json/config.json"),
+    )
+
+    github_response = {
+        "tag_name": "v4.2.0",
+        "body": "Release notes",
+        "html_url": "https://github.com/OpenEVSE/ESP32_WiFi_V4.x/releases/tag/v4.2.0",
+    }
+
+    mock_aioclient.get(
+        "https://api.github.com/repos/OpenEVSE/ESP32_WiFi_V4.x/releases/latest",
+        status=200,
+        body=json.dumps(github_response),
+    )
+
+    # Create OpenEVSE instance without external session (use mocked responses)
+    charger = OpenEVSE(TEST_TLD)
+
+    # Load config first
+    await charger.update()
+
+    # Check firmware - should use mocked session
+    result = await charger.firmware_check()
+
+    # Verify result
+    assert result is not None
+    assert result["latest_version"] == "v4.2.0"
+
+
+async def test_session_not_closed_when_external(mock_aioclient):
+    """Test that external session is not closed by the library."""
+    mock_aioclient.get(
+        TEST_URL_STATUS,
+        status=200,
+        body=load_fixture("v4_json/status.json"),
+    )
+    mock_aioclient.get(
+        TEST_URL_CONFIG,
+        status=200,
+        body=load_fixture("v4_json/config.json"),
+    )
+
+    # Create a real session
+    session = aiohttp.ClientSession()
+
+    try:
+        # Create OpenEVSE instance with external session
+        charger = OpenEVSE(TEST_TLD, session=session)
+
+        # Update to initialize websocket
+        await charger.update()
+
+        # Disconnect websocket
+        await charger.ws_disconnect()
+
+        # Session should still be open (not closed by library)
+        assert not session.closed
+
+    finally:
+        # Clean up the session ourselves
+        await session.close()