python-openevse-http 1.0.2__tar.gz → 1.4.0__tar.gz

python_openevse_http-1.4.0/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,62 @@
+name: 🐛 Bug Report
+labels: ["bug"]
+title: "[Bug]: "
+description: Report a bug in python-openevse-http.
+body:
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is. Tell us what you were trying to do and what happened.
+      placeholder: E.g., calling OpenEVSE.update() raises an exception.
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Steps to reproduce
+      description: Steps to reproduce the behavior.
+      placeholder: |
+        1. Initialize OpenEVSE with ...
+        2. Call ...
+        3. See error
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+  - type: markdown
+    attributes:
+      value: |
+        ## Environment Info
+  - type: input
+    id: version
+    validations:
+      required: true
+    attributes:
+      label: Library version
+      placeholder: e.g., 1.0.0, main branch
+  - type: input
+    id: python_version
+    validations:
+      required: true
+    attributes:
+      label: Python version
+      placeholder: e.g., 3.10, 3.11
+  - type: input
+    id: firmware_version
+    validations:
+      required: false
+    attributes:
+      label: OpenEVSE WiFi Firmware version
+      placeholder: e.g., 4.1.2, 5.0.0
+  - type: textarea
+    attributes:
+      label: Debug Logs / Stack Trace
+      description: Please paste any relevant traceback outputs or logs here (enable debug logging if possible).
+      render: txt
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context or screenshots about the bug here.

python_openevse_http-1.4.0/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Ask a question / Support Request
+    url: https://github.com/firstof9/python-openevse-http/discussions
+    about: Please ask questions and get support on GitHub Discussions.

python_openevse_http-1.4.0/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,25 @@
+name: ✨ Feature Request
+labels: ["feature"]
+title: "[Feature Request]: "
+description: Request a feature for python-openevse-http.
+body:
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Is your feature request related to a problem? Please describe.
+      description: A clear and concise description of what the problem is. E.g. I'm always frustrated when [...]
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+  - type: textarea
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context or screenshots about the feature request here.

python_openevse_http-1.4.0/.github/pull_request_template.md

@@ -0,0 +1,26 @@
+## Description
+
+Please include a summary of the changes and the related issue. Please also include relevant motivation and context.
+
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Code quality / Refactoring
+- [ ] Documentation update
+
+## Checklist
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 1.0.2
+Version: 1.4.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
@@ -84,6 +84,35 @@ async def main():
 if __name__ == "__main__":
     asyncio.run(main())
 ```
+### HTTPS and SSL Verification Options
+
+If your OpenEVSE WiFi/ethernet module uses HTTPS, you can configure the client to connect securely using the `ssl=True` parameter:
+
+```python
+        # Connect securely using HTTPS (validating SSL/TLS certificates)
+        charger = OpenEVSE(
+            "192.168.1.30",
+            session=session,
+            ssl=True,
+        )
+```
+
+#### Bypassing SSL Verification (Self-Signed Certificates)
+
+> [!WARNING]
+> Disabling SSL certificate validation (`ssl_verify=False`) disables TLS verification and exposes the connection to Man-in-the-Middle (MITM) attacks. Only use this configuration when connecting to an OpenEVSE module with a self-signed certificate over a trusted local network.
+
+To bypass certificate verification:
+
+```python
+        # Connect using HTTPS, and disable certificate verification
+        charger = OpenEVSE(
+            "192.168.1.30",
+            session=session,
+            ssl=True,
+            ssl_verify=False,
+        )
+```
 
 ## API Support Matrix
 

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/README.md

@@ -51,6 +51,35 @@ async def main():
 if __name__ == "__main__":
     asyncio.run(main())
 ```
+### HTTPS and SSL Verification Options
+
+If your OpenEVSE WiFi/ethernet module uses HTTPS, you can configure the client to connect securely using the `ssl=True` parameter:
+
+```python
+        # Connect securely using HTTPS (validating SSL/TLS certificates)
+        charger = OpenEVSE(
+            "192.168.1.30",
+            session=session,
+            ssl=True,
+        )
+```
+
+#### Bypassing SSL Verification (Self-Signed Certificates)
+
+> [!WARNING]
+> Disabling SSL certificate validation (`ssl_verify=False`) disables TLS verification and exposes the connection to Man-in-the-Middle (MITM) attacks. Only use this configuration when connecting to an OpenEVSE module with a self-signed certificate over a trusted local network.
+
+To bypass certificate verification:
+
+```python
+        # Connect using HTTPS, and disable certificate verification
+        charger = OpenEVSE(
+            "192.168.1.30",
+            session=session,
+            ssl=True,
+            ssl_verify=False,
+        )
+```
 
 ## API Support Matrix
 

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/example_external_session.py

@@ -49,6 +49,24 @@ async def example_shared_session():
         await charger2.ws_disconnect()
 
 
+async def example_with_https_and_ssl_bypass():
+    """Demonstrate using HTTPS with bypassed SSL verification."""
+    async with aiohttp.ClientSession() as session:
+        # Pass ssl=True to construct an https:// URL,
+        # and ssl_verify=False to bypass certificate validation.
+        charger = OpenEVSE(
+            "192.168.1.30",
+            session=session,
+            ssl=True,
+            ssl_verify=False,
+        )
+
+        # Use the charger normally
+        await charger.update()
+        print(f"Status: {charger.status}")
+        await charger.ws_disconnect()
+
+
 if __name__ == "__main__":
     # Run one of the examples
     asyncio.run(example_with_external_session())

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/openevsehttp/client.py

@@ -53,11 +53,16 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
         user: str | None = None,
         pwd: str | None = None,
         session: aiohttp.ClientSession | None = None,
+        ssl: bool = False,
+        ssl_verify: bool = True,
     ) -> None:
         """Connect to an OpenEVSE charger equipped with wifi or ethernet."""
         self._user = user or ""
         self._pwd = pwd or ""
-        self.url = f"http://{host}/"
+        self.ssl = ssl
+        self.ssl_verify = ssl_verify
+        scheme = "https" if ssl else "http"
+        self.url = f"{scheme}://{host}/"
         self._status: dict[str, Any] = {}
         self._config: dict[str, Any] = {}
         self._override: Any = None
@@ -134,6 +139,8 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
             kwargs = {"data": rapi, "auth": auth}
             if data is not None:
                 kwargs["json"] = data
+            if url.startswith("https://") and not self.ssl_verify:
+                kwargs["ssl"] = False
             async with http_method(url, **kwargs) as resp:
                 try:
                     raw = await resp.text()
@@ -285,6 +292,7 @@ class OpenEVSE(CommandsMixin, ManagersMixin, SensorsMixin, PropertiesMixin):
             self._user,
             self._pwd,
             self._session,
+            ssl_verify=self.ssl_verify,
         )
 
     def _validate_session_loop(self, loop: asyncio.AbstractEventLoop) -> None:

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/openevsehttp/commands.py

@@ -23,6 +23,8 @@ class CommandsMixin:
     """Mixin providing command methods for OpenEVSE."""
 
     url: str
+    ssl: bool
+    ssl_verify: bool
     _status: dict[str, Any]
     _config: dict[str, Any]
     _session: aiohttp.ClientSession | None

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/openevsehttp/const.py

@@ -23,6 +23,8 @@ BAT_RANGE = "battery_range"
 TTF = "time_to_full_charge"
 VOLTAGE = "voltage"
 SHAPER_LIVE = "shaper_live_pwr"
+HOME_BATTERY_SOC = "home_battery_soc"
+HOME_BATTERY_POWER = "home_battery_power"
 TYPE = "type"
 VALUE = "value"
 RELEASE = "release"

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/openevsehttp/sensors.py

@@ -6,7 +6,16 @@ import logging
 from collections.abc import Mapping
 from typing import Any
 
-from .const import BAT_LVL, BAT_RANGE, GRID, SOLAR, TTF, VOLTAGE
+from .const import (
+    BAT_LVL,
+    BAT_RANGE,
+    GRID,
+    HOME_BATTERY_POWER,
+    HOME_BATTERY_SOC,
+    SOLAR,
+    TTF,
+    VOLTAGE,
+)
 from .exceptions import UnsupportedFeature
 
 _LOGGER = logging.getLogger(__name__)
@@ -122,6 +131,34 @@ class SensorsMixin:
             response = await self.process_request(url=url, method="post", data=data)
             _LOGGER.debug("SOC response: %s", self._normalize_response(response))
 
+    # Home/powerwall battery HTTP Posting
+    async def home_battery(
+        self,
+        soc: int | None = None,
+        power: int | None = None,
+    ) -> None:
+        """Send pushed home/powerwall battery data to the charger."""
+        if not self._version_check("4.1.0"):
+            _LOGGER.debug("Feature not supported for older firmware.")
+            raise UnsupportedFeature
+
+        url = f"{self.url}status"
+        data = {}
+
+        if soc is not None:
+            data[HOME_BATTERY_SOC] = soc
+        if power is not None:
+            data[HOME_BATTERY_POWER] = power
+
+        if not data:
+            _LOGGER.info("No home battery data to send to device.")
+        else:
+            _LOGGER.debug("Posting home battery data: %s", data)
+            response = await self.process_request(url=url, method="post", data=data)
+            _LOGGER.debug(
+                "Home battery response: %s", self._normalize_response(response)
+            )
+
     # Shaper HTTP Posting
     async def set_shaper_live_pwr(self, power: int) -> None:
         """Send pushed sensor data to shaper."""

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/openevsehttp/utils.py

@@ -32,7 +32,9 @@ def get_awesome_version(version: str) -> AwesomeVersion:
     # We use custom word boundary checks to avoid false positives like 'domain' matching 'main'
     # or 'webmaster' matching 'master'.
     is_dev = False
-    if re.search(
+    if re.search(r"_modified$", version, re.IGNORECASE):
+        is_dev = True
+    elif re.search(
         r"(?:^|[^a-zA-Z0-9])(master|main)(?:[^a-zA-Z0-9]|$)", version, re.IGNORECASE
     ):
         is_dev = True

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/openevsehttp/websocket.py

@@ -42,9 +42,11 @@ class OpenEVSEWebsocket:
         user: str | None = None,
         password: str | None = None,
         session: aiohttp.ClientSession | None = None,
+        ssl_verify: bool = True,
     ) -> None:
         """Initialize a OpenEVSEWebsocket instance."""
         self.session = session
+        self.ssl_verify = ssl_verify
         self.uri = self._get_uri(server)
         self._user = user
         self._password = password
@@ -133,10 +135,16 @@ class OpenEVSEWebsocket:
         try:
             # Narrow type for mypy since _ensure_session sets self.session
             assert self.session is not None
+            ws_kwargs: dict[str, Any] = {
+                "heartbeat": 15,
+                "auth": auth,
+            }
+            if self.uri.startswith("wss://") and not self.ssl_verify:
+                ws_kwargs["ssl"] = False
+
             async with self.session.ws_connect(
                 self.uri,
-                heartbeat=15,
-                auth=auth,
+                **ws_kwargs,
             ) as ws_client:
                 self._client = ws_client
                 await self._set_state(STATE_CONNECTED)

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/python_openevse_http.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_openevse_http
-Version: 1.0.2
+Version: 1.4.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
@@ -84,6 +84,35 @@ async def main():
 if __name__ == "__main__":
     asyncio.run(main())
 ```
+### HTTPS and SSL Verification Options
+
+If your OpenEVSE WiFi/ethernet module uses HTTPS, you can configure the client to connect securely using the `ssl=True` parameter:
+
+```python
+        # Connect securely using HTTPS (validating SSL/TLS certificates)
+        charger = OpenEVSE(
+            "192.168.1.30",
+            session=session,
+            ssl=True,
+        )
+```
+
+#### Bypassing SSL Verification (Self-Signed Certificates)
+
+> [!WARNING]
+> Disabling SSL certificate validation (`ssl_verify=False`) disables TLS verification and exposes the connection to Man-in-the-Middle (MITM) attacks. Only use this configuration when connecting to an OpenEVSE module with a self-signed certificate over a trusted local network.
+
+To bypass certificate verification:
+
+```python
+        # Connect using HTTPS, and disable certificate verification
+        charger = OpenEVSE(
+            "192.168.1.30",
+            session=session,
+            ssl=True,
+            ssl_verify=False,
+        )
+```
 
 ## API Support Matrix
 

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/python_openevse_http.egg-info/SOURCES.txt

@@ -13,7 +13,11 @@ requirements_test.txt
 setup.py
 tox.ini
 .github/dependabot.yml
+.github/pull_request_template.md
 .github/release-drafter.yml
+.github/ISSUE_TEMPLATE/bug_report.yml
+.github/ISSUE_TEMPLATE/config.yml
+.github/ISSUE_TEMPLATE/feature_request.yml
 .github/workflows/autolabeler.yml
 .github/workflows/links.yml
 .github/workflows/publish-to-pypi.yml

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/requirements_lint.txt

@@ -1,4 +1,4 @@
 -r requirements.txt
-prek==0.4.4
-ruff==0.15.16
+prek==0.4.5
+ruff==0.15.17
 mypy==2.1.0

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/requirements_test.txt

@@ -1,6 +1,6 @@
 -r requirements.txt
-prek==0.4.4
-pytest==9.0.3
+prek==0.4.5
+pytest==9.1.0
 pytest-cov==7.1.0
 pytest-timeout==2.4.0
 pytest-asyncio

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/tests/test_client.py

@@ -671,14 +671,30 @@ async def test_version_check_dev_branches():
     charger._config = {"version": "feature_1A2B3C"}
     assert charger._version_check("2.0.0") is True
 
+    # Suffix matching for _modified - treated as dev, returns True
+    charger._config = {
+        "version": "local_feature/gui-nightshift-default_2bcdf1d0_modified"
+    }
+    assert charger._version_check("2.0.0") is True
+
+    charger._config = {"version": "custom_branch/my-feature_abc123_modified"}
+    assert charger._version_check("2.0.0") is True
+
+    charger._config = {"version": "main_modified"}
+    assert charger._version_check("2.0.0") is True
+
     # False positives containing 'main' or 'master' but not at word boundaries,
-    # or ending in 6-char hashes without dev keywords — should fail version check
+    # ending in 6-char hashes without dev keywords, or other non-matching modified strings
+    # — should fail version check
     charger._config = {"version": "domain_abc123"}
     assert charger._version_check("2.0.0") is False
 
     charger._config = {"version": "webmaster_def456"}
     assert charger._version_check("2.0.0") is False
 
+    charger._config = {"version": "unmodified"}
+    assert charger._version_check("2.0.0") is False
+
     # Pre-release (rc) version — should fail when checking against a newer target
     charger._config = {"version": "4.1.2_rc1"}
     assert charger._version_check("5.0.0") is False
@@ -1871,3 +1887,44 @@ async def test_get_session_no_running_loop_mocked(charger_factory):
     charger = charger_factory()
     with patch("asyncio.get_running_loop", side_effect=RuntimeError):
         assert charger._get_session() is charger._session
+
+
+async def test_ssl_options(mock_aioclient):
+    """Test SSL options and SSL verification configuration."""
+    # 1. Default (ssl=False, ssl_verify=True)
+    charger_default = OpenEVSE(SERVER_URL, session=MockClientSession(mock_aioclient))
+    assert charger_default.url == f"http://{SERVER_URL}/"
+    assert charger_default.ssl is False
+    assert charger_default.ssl_verify is True
+
+    # 2. Secure connection (ssl=True, ssl_verify=True)
+    charger_ssl = OpenEVSE(
+        SERVER_URL, ssl=True, session=MockClientSession(mock_aioclient)
+    )
+    assert charger_ssl.url == f"https://{SERVER_URL}/"
+    assert charger_ssl.ssl is True
+    assert charger_ssl.ssl_verify is True
+
+    # 3. Secure connection with disabled validation (ssl=True, ssl_verify=False)
+    charger_no_verify = OpenEVSE(
+        SERVER_URL,
+        ssl=True,
+        ssl_verify=False,
+        session=MockClientSession(mock_aioclient),
+    )
+    assert charger_no_verify.url == f"https://{SERVER_URL}/"
+    assert charger_no_verify.ssl is True
+    assert charger_no_verify.ssl_verify is False
+
+    # Check request parameter passing
+    url = f"https://{SERVER_URL}/status"
+    mock_aioclient.get(url, status=200, body='{"state": "sleeping"}')
+
+    # When ssl_verify=False, ssl=False should be passed to session request kwargs
+    await charger_no_verify.process_request(url, method="get")
+    assert mock_aioclient.requests[-1][2].get("ssl") is False
+
+    # When ssl_verify=True, ssl should NOT be passed as False
+    mock_aioclient.get(url, status=200, body='{"state": "sleeping"}')
+    await charger_ssl.process_request(url, method="get")
+    assert "ssl" not in mock_aioclient.requests[-1][2]

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/tests/test_sensors.py

@@ -88,6 +88,44 @@ async def test_soc(test_charger, test_charger_v2, mock_aioclient, caplog):
     await test_charger_v2.ws_disconnect()
 
 
+# ── home_battery ─────────────────────────────────────────────────────
+
+
+async def test_home_battery(test_charger, test_charger_v2, mock_aioclient, caplog):
+    """Test home_battery function."""
+    await test_charger.update()
+    mock_aioclient.post(
+        TEST_URL_STATUS,
+        status=200,
+        body='{"home_battery_soc": 82, "home_battery_power": -1500}',
+        repeat=True,
+    )
+    with caplog.at_level(logging.DEBUG):
+        await test_charger.home_battery(82, -1500)
+        assert (
+            "Posting home battery data: {'home_battery_soc': 82, 'home_battery_power': -1500}"
+            in caplog.text
+        )
+        assert (
+            "Home battery response: {'home_battery_soc': 82, 'home_battery_power': -1500}"
+            in caplog.text
+        )
+
+        await test_charger.home_battery(soc=50)
+        assert "Posting home battery data: {'home_battery_soc': 50}" in caplog.text
+
+        await test_charger.home_battery()
+        assert "No home battery data to send to device." in caplog.text
+        await test_charger.ws_disconnect()
+
+    await test_charger_v2.update()
+    with pytest.raises(UnsupportedFeature):
+        with caplog.at_level(logging.DEBUG):
+            await test_charger_v2.home_battery(50, -100)
+    assert "Feature not supported for older firmware." in caplog.text
+    await test_charger_v2.ws_disconnect()
+
+
 # ── voltage ──────────────────────────────────────────────────────────
 
 

{python_openevse_http-1.0.2 → python_openevse_http-1.4.0}/tests/test_websocket.py

@@ -548,3 +548,55 @@ async def test_websocket_close_cancels_pending_tasks(ws_client):
     # Close should cancel and drain tasks
     await ws_client.close()
     assert len(ws_client._tasks) == 0
+
+
+@pytest.mark.asyncio
+async def test_websocket_ssl_options(mock_callback):
+    """Test OpenEVSEWebsocket SSL options and ws_connect parameter passing."""
+    async with aiohttp.ClientSession() as session:
+        # Default ssl_verify=True
+        ws_default = OpenEVSEWebsocket(
+            "https://openevse.test.tld/",
+            mock_callback,
+            session=session,
+        )
+        assert ws_default.ssl_verify is True
+        assert ws_default.uri == "wss://openevse.test.tld/ws"
+
+        # Explicit ssl_verify=False
+        ws_no_verify = OpenEVSEWebsocket(
+            "https://openevse.test.tld/",
+            mock_callback,
+            session=session,
+            ssl_verify=False,
+        )
+        assert ws_no_verify.ssl_verify is False
+        assert ws_no_verify.uri == "wss://openevse.test.tld/ws"
+
+        # Mock ws_connect to check that it is called with ssl=False when ssl_verify=False
+        mock_ws = AsyncMock()
+        mock_ws.__aenter__ = AsyncMock(return_value=mock_ws)
+        mock_ws.__aexit__ = AsyncMock(return_value=None)
+
+        async def empty_iter():
+            return
+            yield
+
+        mock_ws.__aiter__.side_effect = empty_iter
+
+        with patch(
+            "aiohttp.ClientSession.ws_connect", return_value=mock_ws
+        ) as mock_connect:
+            await ws_no_verify.running()
+            mock_connect.assert_called_once()
+            call_kwargs = mock_connect.call_args.kwargs
+            assert call_kwargs.get("ssl") is False
+
+        # When ssl_verify=True, ws_connect should NOT pass ssl=False
+        with patch(
+            "aiohttp.ClientSession.ws_connect", return_value=mock_ws
+        ) as mock_connect:
+            await ws_default.running()
+            mock_connect.assert_called_once()
+            call_kwargs = mock_connect.call_args.kwargs
+            assert "ssl" not in call_kwargs