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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 0.2.5
+Version: 0.2.6
 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
@@ -11,12 +11,10 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.10
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp

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

@@ -6,8 +6,9 @@ import asyncio
 import json
 import logging
 import re
+from collections.abc import Callable
 from datetime import datetime, timedelta, timezone
-from typing import Any, Callable, Dict, Union
+from typing import Any
 
 import aiohttp  # type: ignore
 from aiohttp.client_exceptions import ContentTypeError, ServerTimeoutError
@@ -122,112 +123,79 @@ class OpenEVSE:
             auth = aiohttp.BasicAuth(self._user, self._pwd)
 
         # 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",
-                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
-        else:
+        if (session := self._session) is None:
             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,
+                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
+            )
+
+    async def _process_request_with_session(
+        self,
+        session: aiohttp.ClientSession,
+        url: str,
+        method: str,
+        data: Any,
+        rapi: Any,
+        auth: Any,
+    ) -> dict[str, str] | dict[str, Any]:
+        """Process a request with a given session."""
+        http_method = getattr(session, method)
+        _LOGGER.debug(
+            "Connecting to %s with data: %s rapi: %s using method %s",
+            url,
+            data,
+            rapi,
+            method,
+        )
+        try:
+            kwargs = {"data": rapi, "auth": auth}
+            if data is not None:
+                kwargs["json"] = data
+            async with http_method(url, **kwargs) as resp:
                 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
+                    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:
+                    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"])
+                    else:
+                        _LOGGER.error("Error 400: %s", message)
+                    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 isinstance(message, dict)
+                    and "config_version" in message
+                ):
+                    await self.update()
+                return message
+
+        except (TimeoutError, ServerTimeoutError):
+            _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
+            raise
+        except ContentTypeError as err:
+            _LOGGER.error("Content error: %s", err.message)
+            raise
 
     async def send_command(self, command: str) -> tuple:
         """Send a RAPI command to the charger and parses the response."""
@@ -387,7 +355,7 @@ class OpenEVSE:
             await asyncio.sleep(interval)
             await func(*args, **kwargs)
 
-    async def get_schedule(self) -> Union[Dict[str, str], Dict[str, Any]]:
+    async def get_schedule(self) -> dict[str, str] | dict[str, Any]:
         """Return the current schedule."""
         url = f"{self.url}schedule"
 
@@ -406,9 +374,7 @@ class OpenEVSE:
         data = {"charge_mode": mode}
 
         _LOGGER.debug("Setting charge mode to %s", mode)
-        response = await self.process_request(
-            url=url, method="post", data=data
-        )  # noqa: E501
+        response = await self.process_request(url=url, method="post", data=data)
         result = response["msg"]
         if result not in ["done", "no change"]:
             _LOGGER.error("Problem issuing command: %s", response["msg"])
@@ -433,13 +399,11 @@ class OpenEVSE:
         data = {"divert_enabled": mode}
 
         _LOGGER.debug("Toggling divert: %s", mode)
-        response = await self.process_request(
-            url=url, method="post", data=data
-        )  # noqa: E501
+        response = await self.process_request(url=url, method="post", data=data)
         _LOGGER.debug("divert_mode response: %s", response)
         return response
 
-    async def get_override(self) -> Union[Dict[str, str], Dict[str, Any]]:
+    async def get_override(self) -> dict[str, str] | dict[str, Any]:
         """Get the manual override status."""
         if not self._version_check("4.0.1"):
             _LOGGER.debug("Feature not supported for older firmware.")
@@ -486,9 +450,7 @@ class OpenEVSE:
 
         _LOGGER.debug("Override data: %s", data)
         _LOGGER.debug("Setting override config on %s", url)
-        response = await self.process_request(
-            url=url, method="post", data=data
-        )  # noqa: E501
+        response = await self.process_request(url=url, method="post", data=data)
         return response
 
     async def toggle_override(self) -> None:
@@ -559,9 +521,7 @@ class OpenEVSE:
         data = {"service": level}
 
         _LOGGER.debug("Set service level to: %s", level)
-        response = await self.process_request(
-            url=url, method="post", data=data
-        )  # noqa: E501
+        response = await self.process_request(url=url, method="post", data=data)
         _LOGGER.debug("service response: %s", response)
         result = response["msg"]
         if result not in ["done", "no change"]:
@@ -633,42 +593,11 @@ class OpenEVSE:
             return None
 
         try:
-            if self._session:
-                session = self._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
-            else:
+            if (session := self._session) is None:
                 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
+                    return await self._firmware_check_with_session(session, url, method)
+            else:
+                return await self._firmware_check_with_session(session, url, method)
 
         except (TimeoutError, ServerTimeoutError):
             _LOGGER.error("%s: %s", ERROR_TIMEOUT, url)
@@ -679,6 +608,33 @@ class OpenEVSE:
 
         return None
 
+    async def _firmware_check_with_session(
+        self, session: aiohttp.ClientSession, url: str, method: str
+    ) -> dict | None:
+        """Process a firmware check request with a given 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()
+            try:
+                message = json.loads(message)
+            except json.JSONDecodeError:
+                _LOGGER.error("Failed to parse JSON response: %s", message)
+                return None
+
+            response = {}
+            if isinstance(message, dict):
+                response["latest_version"] = message.get("tag_name")
+                response["release_notes"] = message.get("body")
+                response["release_url"] = message.get("html_url")
+            return response
+
     def _version_check(self, min_version: str, max_version: str = "") -> bool:
         """Return bool if minimum version is met."""
         if "version" not in self._config:
@@ -831,7 +787,7 @@ class OpenEVSE:
             raise UnsupportedFeature
 
         url = f"{self.url}limit"
-        data: Dict[str, Any] = await self.get_limit()
+        data: dict[str, Any] = await self.get_limit()
         valid_types = ["time", "energy", "soc", "range"]
 
         if limit_type not in valid_types:
@@ -844,9 +800,7 @@ class OpenEVSE:
 
         _LOGGER.debug("Limit data: %s", data)
         _LOGGER.debug("Setting limit config on %s", url)
-        response = await self.process_request(
-            url=url, method="post", data=data
-        )  # noqa: E501
+        response = await self.process_request(url=url, method="post", data=data)
         return response
 
     async def clear_limit(self) -> Any:
@@ -856,12 +810,9 @@ class OpenEVSE:
             raise UnsupportedFeature
 
         url = f"{self.url}limit"
-        data: Dict[str, Any] = {}
 
         _LOGGER.debug("Clearing limit config on %s", url)
-        response = await self.process_request(
-            url=url, method="delete", data=data
-        )  # noqa: E501
+        response = await self.process_request(url=url, method="delete")
         return response
 
     async def get_limit(self) -> Any:
@@ -871,12 +822,9 @@ class OpenEVSE:
             raise UnsupportedFeature
 
         url = f"{self.url}limit"
-        data: Dict[str, Any] = {}
 
         _LOGGER.debug("Getting limit config on %s", url)
-        response = await self.process_request(
-            url=url, method="get", data=data
-        )  # noqa: E501
+        response = await self.process_request(url=url, method="get")
         return response
 
     async def make_claim(
@@ -911,9 +859,7 @@ class OpenEVSE:
 
         _LOGGER.debug("Claim data: %s", data)
         _LOGGER.debug("Setting up claim on %s", url)
-        response = await self.process_request(
-            url=url, method="post", data=data
-        )  # noqa: E501
+        response = await self.process_request(url=url, method="post", data=data)
         return response
 
     async def release_claim(self, client: int = CLIENT) -> Any:
@@ -925,7 +871,7 @@ class OpenEVSE:
         url = f"{self.url}claims/{client}"
 
         _LOGGER.debug("Releasing claim on %s", url)
-        response = await self.process_request(url=url, method="delete")  # noqa: E501
+        response = await self.process_request(url=url, method="delete")
         return response
 
     async def list_claims(self, target: bool | None = None) -> Any:
@@ -941,7 +887,7 @@ class OpenEVSE:
         url = f"{self.url}claims{target_check}"
 
         _LOGGER.debug("Getting claims on %s", url)
-        response = await self.process_request(url=url, method="get")  # noqa: E501
+        response = await self.process_request(url=url, method="get")
         return response
 
     async def set_led_brightness(self, level: int) -> None:
@@ -955,7 +901,7 @@ class OpenEVSE:
 
         data["led_brightness"] = level
         _LOGGER.debug("Setting LED brightness to %s", level)
-        await self.process_request(url=url, method="post", data=data)  # noqa: E501
+        await self.process_request(url=url, method="post", data=data)
 
     async def set_divert_mode(self, mode: str = "fast") -> None:
         """Set the divert mode."""
@@ -1418,7 +1364,7 @@ class OpenEVSE:
     # Safety counts
     @property
     def checks_count(self) -> dict:
-        """Return the saftey checks counts."""
+        """Return the safety checks counts."""
         attributes = ("gfcicount", "nogndcount", "stuckcount")
         counts = {}
         if self._status is not None and set(attributes).issubset(self._status.keys()):

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

@@ -170,7 +170,7 @@ class OpenEVSEWebsocket:
         if self._ping and self._pong:
             time_delta = self._pong - self._ping
             if time_delta < datetime.timedelta(0):
-                # Negitive time should indicate no pong reply so consider the
+                # Negative time should indicate no pong reply so consider the
                 # websocket disconnected.
                 self._error_reason = ERROR_PING_TIMEOUT
                 await self._set_state(STATE_DISCONNECTED)

python_openevse_http-0.2.6/pyproject.toml

@@ -0,0 +1,32 @@
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "C",  # flake8-comprehensions
+    "B",  # flake8-bugbear
+    "UP", # pyupgrade
+    "D",  # pydocstyle
+]
+ignore = [
+    "D100", # missing docstring in public module
+    "D101", # missing docstring in public class
+    "D102", # missing docstring in public method
+    "D103", # missing docstring in public function
+    "D104", # missing docstring in public package
+    "D105", # missing docstring in magic method
+    "D106", # missing docstring in public nested class
+    "D107", # missing docstring in __init__
+    "D202", # No blank lines allowed after function docstring
+    "D203", # 1 blank line required before class docstring
+    "D213", # Multi-line docstring summary should start at the second line
+    "E501", # line too long
+]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 18

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 0.2.5
+Version: 0.2.6
 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
@@ -11,12 +11,10 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.10
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp

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

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+pyproject.toml
 setup.py
 openevsehttp/__init__.py
 openevsehttp/__main__.py

{python_openevse_http-0.2.5 → python_openevse_http-0.2.6}/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.5"
+VERSION = "0.2.6"
 
 setup(
     name="python_openevse_http",
@@ -19,7 +19,7 @@ setup(
     long_description=README_FILE.read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",
     packages=find_packages(exclude=["test.*", "tests"]),
-    python_requires=">=3.10",
+    python_requires=">=3.13",
     install_requires=["aiohttp"],
     license="Apache-2.0",
     entry_points={},
@@ -30,10 +30,8 @@ setup(
         "Intended Audience :: Developers",
         "Natural Language :: English",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
         "License :: OSI Approved :: Apache Software License",
     ],
 )

{python_openevse_http-0.2.5 → python_openevse_http-0.2.6}/tests/test_main.py

@@ -150,6 +150,16 @@ async def test_send_command_parse_err(test_charger_auth, mock_aioclient):
         status = await test_charger_auth.send_command("test")
         assert status is None
 
+    mock_aioclient.post(TEST_URL_RAPI, status=400, body='{"other": "Something else"}')
+    with pytest.raises(main.ParseJSONError):
+        status = await test_charger_auth.send_command("test")
+        assert status is None
+
+    mock_aioclient.post(TEST_URL_RAPI, status=400, body='"Just a string response"')
+    with pytest.raises(main.ParseJSONError):
+        status = await test_charger_auth.send_command("test")
+        assert status is None
+
 
 async def test_send_command_auth_err(test_charger_auth, mock_aioclient):
     """Test v4 Status reply."""
@@ -854,7 +864,7 @@ async def test_toggle_override_v2_err(test_charger_v2, mock_aioclient, caplog):
     """Test v4 Status reply."""
     await test_charger_v2.update()
     content_error = mock.Mock()
-    setattr(content_error, "real_url", f"{TEST_URL_RAPI}")
+    content_error.real_url = f"{TEST_URL_RAPI}"
     mock_aioclient.post(
         TEST_URL_RAPI,
         exception=ContentTypeError(
@@ -1069,7 +1079,7 @@ async def test_set_divertmode(
 
 
 async def test_test_and_get(test_charger, test_charger_v2, mock_aioclient, caplog):
-    """Test v4 Status reply"""
+    """Test v4 Status reply."""
     data = await test_charger.test_and_get()
     mock_aioclient.get(
         TEST_URL_CONFIG,
@@ -1108,7 +1118,7 @@ async def test_firmware_check(
     mock_aioclient,
     caplog,
 ):
-    """Test v4 Status reply"""
+    """Test v4 Status reply."""
     await test_charger.update()
     mock_aioclient.get(
         TEST_URL_GITHUB_v4,
@@ -3164,6 +3174,14 @@ async def test_firmware_check_errors(mock_aioclient):
     )
     assert await charger.firmware_check() is None
 
+    # JSONDecodeError from github
+    mock_aioclient.get(url, status=200, body="not json")
+    assert await charger.firmware_check() is None
+
+    # Non-dict JSON from github
+    mock_aioclient.get(url, status=200, body='"just a string"')
+    assert await charger.firmware_check() == {}
+
 
 async def test_websocket_pong():
     """Test websocket handles pong message."""

{python_openevse_http-0.2.5 → python_openevse_http-0.2.6}/tests/test_websocket.py

@@ -294,7 +294,6 @@ async def test_state_setter_threadsafe_fallback(ws_client):
         ) as mock_create_task,
         patch("asyncio.get_event_loop", return_value=mock_loop),
     ):
-
         ws_client.state = STATE_CONNECTED
         assert ws_client.state == STATE_CONNECTED