pySmartHashtag 0.12.2__tar.gz → 0.13.0__tar.gz

{pysmarthashtag-0.12.2/pySmartHashtag.egg-info → pysmarthashtag-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pySmartHashtag
-Version: 0.12.2
+Version: 0.13.0
 Summary: A python library to get information from Smart #1, #3 and #5 web API
 Home-page: https://github.com/dasBasti/pySmartHashtag
 Author: dasBasti

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0/pySmartHashtag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pySmartHashtag
-Version: 0.12.2
+Version: 0.13.0
 Summary: A python library to get information from Smart #1, #3 and #5 web API
 Home-page: https://github.com/dasBasti/pySmartHashtag
 Author: dasBasti

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0}/pySmartHashtag.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ pysmarthashtag/api/utils.py
 pysmarthashtag/control/charging.py
 pysmarthashtag/control/climate.py
 pysmarthashtag/control/journal.py
+pysmarthashtag/control/lock.py
 pysmarthashtag/tests/__init__.py
 pysmarthashtag/tests/common.py
 pysmarthashtag/tests/conftest.py
@@ -49,13 +50,16 @@ pysmarthashtag/tests/test_actions.py
 pysmarthashtag/tests/test_authentication_backoff.py
 pysmarthashtag/tests/test_charging.py
 pysmarthashtag/tests/test_charging_states.py
+pysmarthashtag/tests/test_cli.py
 pysmarthashtag/tests/test_dc_charging.py
 pysmarthashtag/tests/test_endpoint_urls.py
 pysmarthashtag/tests/test_journal.py
 pysmarthashtag/tests/test_journal_control.py
 pysmarthashtag/tests/test_journal_pagination.py
+pysmarthashtag/tests/test_lock_control.py
 pysmarthashtag/tests/test_log_sanitizer.py
 pysmarthashtag/tests/test_missing_fields.py
+pysmarthashtag/tests/test_ota_info.py
 pysmarthashtag/tests/test_ssl_context.py
 pysmarthashtag/tests/test_token_lifecycle.py
 pysmarthashtag/tests/test_tracked_vins.py

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0}/pySmartHashtag.egg-info/scm_file_list.json

@@ -29,6 +29,7 @@
     "pysmarthashtag/control/charging.py",
     "pysmarthashtag/control/climate.py",
     "pysmarthashtag/control/journal.py",
+    "pysmarthashtag/control/lock.py",
     "pysmarthashtag/models.py",
     "pysmarthashtag/tests/__init__.py",
     "pysmarthashtag/tests/common.py",
@@ -58,13 +59,16 @@
     "pysmarthashtag/tests/test_authentication_backoff.py",
     "pysmarthashtag/tests/test_charging.py",
     "pysmarthashtag/tests/test_charging_states.py",
+    "pysmarthashtag/tests/test_cli.py",
     "pysmarthashtag/tests/test_dc_charging.py",
     "pysmarthashtag/tests/test_endpoint_urls.py",
     "pysmarthashtag/tests/test_journal.py",
     "pysmarthashtag/tests/test_journal_control.py",
     "pysmarthashtag/tests/test_journal_pagination.py",
+    "pysmarthashtag/tests/test_lock_control.py",
     "pysmarthashtag/tests/test_log_sanitizer.py",
     "pysmarthashtag/tests/test_missing_fields.py",
+    "pysmarthashtag/tests/test_ota_info.py",
     "pysmarthashtag/tests/test_ssl_context.py",
     "pysmarthashtag/tests/test_token_lifecycle.py",
     "pysmarthashtag/tests/test_tracked_vins.py",

pysmarthashtag-0.13.0/pySmartHashtag.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.13.0",
+  "distance": 0,
+  "node": "ge800cedef883c6b06cee7b097669761c4cd4b1dd",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-29"
+}

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0}/pysmarthashtag/account.py

@@ -50,6 +50,13 @@ VALID_UNTIL_OFFSET = datetime.timedelta(seconds=10)
 # blip mid-loop doesn't fail the whole poll.
 _BENIGN_EMPTY_CODE = "8153"
 
+# Cloud's code on the OTA endpoint for vehicles it has no update record
+# for (reported on Smart #5). It is a property of the OTA service, not of
+# the session: refreshing the token does not clear it, so a poll loop that
+# treats it as an unmapped code refreshes the session on every cycle for
+# nothing. OTA data is optional, so callers normalise this to "no OTA info".
+_OTA_NO_DATA_CODE = "1003"
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -931,8 +938,18 @@ class SmartAccount:
                     await self.select_active_vehicle(vin)
                     continue
                 except httpx.HTTPStatusError as exc:
-                    # Unmapped code: one refresh in case the session is stale, then surface.
                     code = _cloud_code(exc)
+                    if code == _OTA_NO_DATA_CODE:
+                        # The OTA service has nothing to report for this VIN.
+                        # Optional data, and no session remedy applies — return
+                        # empty rather than burning a refresh on every poll.
+                        _LOGGER.debug(
+                            "OTA endpoint returned cloud code %s for %s; no OTA info available",
+                            code,
+                            sanitize_log_data(vin),
+                        )
+                        return {}
+                    # Unmapped code: one refresh in case the session is stale, then surface.
                     if code is None or refreshed_unmapped:
                         raise
                     refreshed_unmapped = True

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0}/pysmarthashtag/cli.py

@@ -6,6 +6,7 @@ import asyncio
 import logging.config
 import os
 import time
+from typing import Optional
 
 from pysmarthashtag.account import SmartAccount
 from pysmarthashtag.control.climate import HeatingLocation
@@ -73,6 +74,10 @@ def main_parser() -> argparse.ArgumentParser:
     seatheating_parser.add_argument("--temp", help="Temperature", default=22)
     seatheating_parser.add_argument("--active", help="Active", action="store_true")
 
+    defrost_parser = subparsers.add_parser("defrost", help="Set front windscreen defrost of vehicle.")
+    defrost_parser.add_argument("--vin", help="VIN of vehicle", default=None)
+    defrost_parser.add_argument("--active", help="Active", action="store_true")
+
     _add_default_args(parser)
     parser.set_defaults(func=parse_command)
 
@@ -91,6 +96,8 @@ async def parse_command(args) -> None:
         await set_climate(args)
     elif args.command == "seatheating":
         await set_seatheating(args)
+    elif args.command == "defrost":
+        await set_defrost(args)
     else:
         raise NotImplementedError(f"Command {args.command} not implemented.")
 
@@ -127,12 +134,27 @@ async def watch_car(args) -> None:
         time.sleep(args.i)
 
 
+def _select_vin(account: SmartAccount, vin: Optional[str]) -> str:
+    """Return the VIN to control, defaulting to the first vehicle of the account.
+
+    Raises SystemExit with an actionable message if the account has no vehicles
+    or the requested VIN does not belong to the account.
+    """
+    vehicles = account.vehicles or {}
+    if not vehicles:
+        raise SystemExit("No vehicles found for this account; nothing to control.")
+    if not vin:
+        return next(iter(vehicles))
+    if vin not in vehicles:
+        raise SystemExit(f"VIN {vin} not found in this account. Available VINs: {', '.join(vehicles)}")
+    return vin
+
+
 async def set_climate(args) -> None:
     """Set climate of vehicle."""
     account = SmartAccount(args.username, args.password)
     await account.get_vehicles()
-    if not args.vin:
-        args.vin = list(account.vehicles.keys())[0]
+    args.vin = _select_vin(account, args.vin)
     await account.get_vehicle_information(args.vin)
 
     climate_ctrl = account.vehicles[args.vin].climate_control
@@ -143,8 +165,7 @@ async def set_seatheating(args) -> None:
     """Set heating of driver's seat in vehicle."""
     account = SmartAccount(args.username, args.password)
     await account.get_vehicles()
-    if not args.vin:
-        args.vin = list(account.vehicles.keys())[0]
+    args.vin = _select_vin(account, args.vin)
     await account.get_vehicle_information(args.vin)
 
     climate_ctrl = account.vehicles[args.vin].climate_control
@@ -152,6 +173,17 @@ async def set_seatheating(args) -> None:
     await climate_ctrl.set_climate_conditioning(args.temp, args.active)
 
 
+async def set_defrost(args) -> None:
+    """Set front windscreen defrost of vehicle."""
+    account = SmartAccount(args.username, args.password)
+    await account.get_vehicles()
+    args.vin = _select_vin(account, args.vin)
+    await account.get_vehicle_information(args.vin)
+
+    climate_ctrl = account.vehicles[args.vin].climate_control
+    await climate_ctrl.set_defrost(args.active)
+
+
 def _add_default_args(parser: argparse.ArgumentParser):
     """Add the default arguments username, password to the parser."""
     parser.add_argument("--username", help="Smart username", **environ_or_required("SMART_USERNAME"))

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0}/pysmarthashtag/control/climate.py

@@ -42,6 +42,7 @@ class ClimateControll:
         },
         "serviceId": "RCE_2",
     }
+    DEFROST_DURATION = 90
 
     def __init__(self, account: SmartAccount, vin: str):
         """Initialize the vehicle."""
@@ -101,14 +102,38 @@ class ClimateControll:
             raise ValueError("Temperature must be between 16 and 30 degrees.")
         self.conditioning_temp = float(temp)
 
+        _LOGGER.debug("Setting climate conditioning: active=%s, temp=%.1f", active, self.conditioning_temp)
+        return await self._send_rce_command(self._get_payload(active))
+
+    def _get_defrost_payload(self, active: bool) -> str:
+        _payload = self.BASE_PAYLOAD_TEMPLATE.copy()
+        _payload["command"] = "start" if active else "stop"
+        _payload["timestamp"] = utils.create_correct_timestamp()
+        _payload["operationScheduling"] = {
+            **self.BASE_PAYLOAD_TEMPLATE["operationScheduling"],
+            "duration": self.DEFROST_DURATION if active else 0,
+        }
+        _payload["serviceParameters"] = [
+            {"key": "rce.conditioner", "value": "2"},
+            {"key": "rce.level", "value": "2"},
+        ]
+        return json.dumps(_payload).replace(" ", "")
+
+    async def set_defrost(self, active: bool) -> bool:
+        """Start or stop the front windscreen defrost."""
+        if not isinstance(active, bool):
+            raise TypeError("Defrost state must be a boolean")
+        _LOGGER.debug("Setting front windscreen defrost: active=%s", active)
+        return await self._send_rce_command(self._get_defrost_payload(active))
+
+    async def _send_rce_command(self, params: str) -> bool:
+        """Send a remote climate command to the vehicle."""
         # Ensure SSL context is created before using the client
         await self.account._ensure_ssl_context()
 
         await self.account.select_active_vehicle(self.vin)
 
         async with SmartClient(self.config) as client:
-            params = self._get_payload(active)
-            _LOGGER.debug("Setting climate conditioning: active=%s, temp=%.1f", active, self.conditioning_temp)
             for retry in range(3):
                 try:
                     vehicles_response = await client.put(

pysmarthashtag-0.13.0/pysmarthashtag/control/lock.py

@@ -0,0 +1,128 @@
+"""Provides an accessible control of the vehicle's door locks."""
+
+import json
+import logging
+
+from pysmarthashtag.account import SmartAccount
+from pysmarthashtag.api import utils
+from pysmarthashtag.api.client import SmartClient
+from pysmarthashtag.const import API_TELEMATICS_URL
+from pysmarthashtag.models import (
+    SmartHumanCarConnectionError,
+    SmartTokenRefreshNecessary,
+    SmartVehicleNotInUseError,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DoorLockControl:
+    """Provides an accessible control of the vehicle's door locks.
+
+    Uses the remote door lock (RDL_2) and remote door unlock (RDU_2)
+    telematics services.
+    """
+
+    LOCK_SERVICE_ID = "RDL_2"
+    UNLOCK_SERVICE_ID = "RDU_2"
+
+    def __init__(self, account: SmartAccount, vin: str):
+        """Initialize the door lock control.
+
+        Args:
+        ----
+            account: The Smart account instance
+            vin: Vehicle identification number
+
+        """
+        self.account = account
+        self.config = account.config
+        self.vin = vin
+
+    def _get_payload(self, service_id: str, parameter: dict[str, str]) -> str:
+        """Create the payload for a door lock command.
+
+        Args:
+        ----
+            service_id: The telematics service to call (RDL_2 or RDU_2)
+            parameter: The service parameter selecting what to (un)lock
+
+        Returns:
+        -------
+            JSON string payload for the API request
+
+        """
+        _payload = {
+            "creator": "tc",
+            "command": "start",
+            "operationScheduling": {
+                "duration": 6,
+                "interval": 0,
+                "occurs": 1,
+                "recurrentOperation": False,
+            },
+            "serviceId": service_id,
+            "timestamp": utils.create_correct_timestamp(),
+            "serviceParameters": [parameter],
+        }
+        return json.dumps(_payload).replace(" ", "")
+
+    async def lock(self) -> bool:
+        """Lock all doors of the vehicle.
+
+        Returns
+        -------
+            True if the command was accepted, False otherwise
+
+        """
+        _LOGGER.debug("Locking all doors")
+        return await self._send_command(self._get_payload(self.LOCK_SERVICE_ID, {"key": "door", "value": "all"}))
+
+    async def unlock(self) -> bool:
+        """Unlock all doors of the vehicle.
+
+        Returns
+        -------
+            True if the command was accepted, False otherwise
+
+        """
+        _LOGGER.debug("Unlocking all doors")
+        return await self._send_command(self._get_payload(self.UNLOCK_SERVICE_ID, {"key": "door", "value": "all"}))
+
+    async def _send_command(self, params: str) -> bool:
+        """Send a door lock command to the vehicle."""
+        # Ensure SSL context is created before using the client
+        await self.account._ensure_ssl_context()
+
+        await self.account.select_active_vehicle(self.vin)
+
+        async with SmartClient(self.config) as client:
+            for retry in range(3):
+                try:
+                    response = await client.put(
+                        self.account.vehicles[self.vin].base_url + API_TELEMATICS_URL + self.vin,
+                        headers={
+                            **utils.generate_default_header(
+                                client.config.authentication.device_id,
+                                client.config.authentication.api_access_token,
+                                params={},
+                                method="PUT",
+                                url=API_TELEMATICS_URL + self.vin,
+                                body=params,
+                                vin=self.vin,
+                                model_code=self.account._vin_model_code(self.vin),
+                            )
+                        },
+                        content=params.encode("utf-8"),
+                    )
+                    api_result = response.json()
+                    return api_result["success"]
+                except SmartTokenRefreshNecessary:
+                    _LOGGER.debug("Session token expired; refreshing (retry %d)", retry)
+                    await self.config.authentication.refresh()
+                    continue
+                except (SmartHumanCarConnectionError, SmartVehicleNotInUseError):
+                    _LOGGER.debug("VIN binding lost (8006/4038); re-binding vehicle (retry %d)", retry)
+                    await self.account.select_active_vehicle(self.vin)
+                    continue
+        return False

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0}/pysmarthashtag/tests/test_actions.py

@@ -1,3 +1,5 @@
+import json
+
 import pytest
 import respx
 
@@ -72,3 +74,60 @@ async def test_enable_seatheating_invalid_level(smart_fixture: respx.Router):
     with pytest.raises(ValueError) as excinfo:
         climate_ctrl.set_heating_level(HeatingLocation.DRIVER_SEAT, 4)
     assert str(excinfo.value) == "Seat heating level must be between 0 and 3."
+
+
+def _last_telematics_payload(router: respx.Router) -> dict:
+    """Return the JSON body of the most recent telematics PUT request."""
+    calls = [c for c in router.calls if c.request.method == "PUT" and "/vehicle/telematics/" in c.request.url.path]
+    assert calls, "No telematics request was sent"
+    return json.loads(calls[-1].request.content)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("active", "command", "duration"),
+    [(True, "start", 90), (False, "stop", 0)],
+)
+async def test_set_defrost(smart_fixture: respx.Router, active: bool, command: str, duration: int):
+    """Test that set_defrost sends the RCE_2 defrost command."""
+    account = await prepare_account_with_vehicles()
+    await account.get_vehicle_information("TestVIN0000000001")
+    climate_ctrl = account.vehicles["TestVIN0000000001"].climate_control
+
+    result = await climate_ctrl.set_defrost(active)
+
+    assert result
+    payload = _last_telematics_payload(smart_fixture)
+    assert payload["serviceId"] == "RCE_2"
+    assert payload["command"] == command
+    assert payload["operationScheduling"]["duration"] == duration
+    assert payload["serviceParameters"] == [
+        {"key": "rce.conditioner", "value": "2"},
+        {"key": "rce.level", "value": "2"},
+    ]
+
+
+@pytest.mark.asyncio
+async def test_set_defrost_does_not_touch_conditioning_template(smart_fixture: respx.Router):
+    """Test that a defrost command leaves the climate conditioning payload unchanged."""
+    account = await prepare_account_with_vehicles()
+    await account.get_vehicle_information("TestVIN0000000001")
+    climate_ctrl = account.vehicles["TestVIN0000000001"].climate_control
+
+    await climate_ctrl.set_defrost(True)
+    await climate_ctrl.set_climate_conditioning(20, True)
+
+    payload = _last_telematics_payload(smart_fixture)
+    assert payload["operationScheduling"]["duration"] == 180
+    assert {"key": "rce.conditioner", "value": "1"} in payload["serviceParameters"]
+
+
+@pytest.mark.asyncio
+async def test_set_defrost_invalid_state(smart_fixture: respx.Router):
+    """Test that set_defrost rejects non-boolean states."""
+    account = await prepare_account_with_vehicles()
+    await account.get_vehicle_information("TestVIN0000000001")
+    climate_ctrl = account.vehicles["TestVIN0000000001"].climate_control
+
+    with pytest.raises(TypeError):
+        await climate_ctrl.set_defrost("on")

pysmarthashtag-0.13.0/pysmarthashtag/tests/test_cli.py

@@ -0,0 +1,44 @@
+"""Tests for the command line interface helpers."""
+
+import pytest
+import respx
+
+from pysmarthashtag.cli import _select_vin
+from pysmarthashtag.tests.conftest import prepare_account_with_vehicles
+
+
+@pytest.mark.asyncio
+async def test_select_vin_defaults_to_first_vehicle(smart_fixture: respx.Router):
+    """Test that the first vehicle is selected when no VIN is given."""
+    account = await prepare_account_with_vehicles()
+
+    assert _select_vin(account, None) == next(iter(account.vehicles))
+
+
+@pytest.mark.asyncio
+async def test_select_vin_accepts_known_vin(smart_fixture: respx.Router):
+    """Test that a VIN belonging to the account is returned unchanged."""
+    account = await prepare_account_with_vehicles()
+
+    assert _select_vin(account, "TestVIN0000000002") == "TestVIN0000000002"
+
+
+@pytest.mark.asyncio
+async def test_select_vin_rejects_unknown_vin(smart_fixture: respx.Router):
+    """Test that a VIN not in the account is rejected with the available VINs."""
+    account = await prepare_account_with_vehicles()
+
+    with pytest.raises(SystemExit, match="VIN UnknownVIN not found in this account") as excinfo:
+        _select_vin(account, "UnknownVIN")
+    assert "TestVIN0000000001" in str(excinfo.value)
+
+
+@pytest.mark.parametrize("vin", [None, "TestVIN0000000001"])
+def test_select_vin_rejects_account_without_vehicles(vin):
+    """Test that an account without vehicles is rejected."""
+
+    class _EmptyAccount:
+        vehicles: dict = {}
+
+    with pytest.raises(SystemExit, match="No vehicles found"):
+        _select_vin(_EmptyAccount(), vin)

pysmarthashtag-0.13.0/pysmarthashtag/tests/test_lock_control.py

@@ -0,0 +1,105 @@
+"""Tests for the remote door lock control."""
+
+import json
+from unittest.mock import AsyncMock, patch
+
+import httpx
+import pytest
+import respx
+
+from pysmarthashtag.tests.conftest import prepare_account_with_vehicles
+
+
+def _last_telematics_payload(router: respx.Router) -> dict:
+    """Return the JSON body of the most recent telematics PUT request."""
+    calls = [c for c in router.calls if c.request.method == "PUT" and "/vehicle/telematics/" in c.request.url.path]
+    assert calls, "No telematics request was sent"
+    return json.loads(calls[-1].request.content)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("method", "service_id", "parameter"),
+    [
+        ("lock", "RDL_2", {"key": "door", "value": "all"}),
+        ("unlock", "RDU_2", {"key": "door", "value": "all"}),
+    ],
+)
+async def test_door_lock_commands(smart_fixture: respx.Router, method: str, service_id: str, parameter: dict):
+    """Test that each lock command sends the matching telematics service."""
+    account = await prepare_account_with_vehicles()
+    await account.get_vehicle_information("TestVIN0000000001")
+    lock_ctrl = account.vehicles["TestVIN0000000001"].door_lock_control
+    assert lock_ctrl is not None
+
+    result = await getattr(lock_ctrl, method)()
+
+    assert result
+    payload = _last_telematics_payload(smart_fixture)
+    assert payload["serviceId"] == service_id
+    assert payload["command"] == "start"
+    assert payload["serviceParameters"] == [parameter]
+
+
+TELEMATICS_URL = "https://api.ecloudeu.com/remote-control/vehicle/telematics/TestVIN0000000001"
+SUCCESS = {"code": 1000, "success": True, "message": "operation succeed", "data": {}}
+
+
+def _last_telematics_request(router: respx.Router):
+    calls = [c for c in router.calls if c.request.method == "PUT" and "/vehicle/telematics/" in c.request.url.path]
+    assert calls, "No telematics request was sent"
+    return calls[-1].request
+
+
+@pytest.mark.asyncio
+async def test_door_lock_sends_vin_headers(smart_fixture: respx.Router):
+    """Test that lock commands are bound to the VIN instead of the active vehicle."""
+    account = await prepare_account_with_vehicles()
+    await account.get_vehicle_information("TestVIN0000000001")
+
+    await account.vehicles["TestVIN0000000001"].door_lock_control.lock()
+
+    request = _last_telematics_request(smart_fixture)
+    assert request.headers["X-Vehicle-IDENTIFIER"] == "TestVIN0000000001"
+    assert request.headers["X-VEHICLE-MODEL"] == "TestVIN0000000001"
+
+
+@pytest.mark.asyncio
+async def test_door_lock_refreshes_token_before_retry(smart_fixture: respx.Router):
+    """Test that an expired session token is refreshed before retrying."""
+    account = await prepare_account_with_vehicles()
+    await account.get_vehicle_information("TestVIN0000000001")
+    smart_fixture.put(TELEMATICS_URL).mock(
+        side_effect=[
+            httpx.Response(200, json={"code": "1402", "message": "token expired"}),
+            httpx.Response(200, json=SUCCESS),
+        ]
+    )
+
+    with patch.object(account.config.authentication, "refresh", new=AsyncMock()) as refresh:
+        result = await account.vehicles["TestVIN0000000001"].door_lock_control.unlock()
+
+    assert result
+    refresh.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("code", ["8006", "4038"])
+async def test_door_lock_rebinds_vehicle_before_retry(smart_fixture: respx.Router, code: str):
+    """Test that a lost vehicle binding is restored before retrying."""
+    account = await prepare_account_with_vehicles()
+    await account.get_vehicle_information("TestVIN0000000001")
+    smart_fixture.put(TELEMATICS_URL).mock(
+        side_effect=[
+            httpx.Response(200, json={"code": code, "message": "binding lost"}),
+            httpx.Response(200, json=SUCCESS),
+        ]
+    )
+
+    with patch.object(account, "select_active_vehicle", new=AsyncMock()) as select:
+        result = await account.vehicles["TestVIN0000000001"].door_lock_control.lock()
+
+    assert result
+    # Once before the first attempt, once more before the retry
+    assert select.await_count == 2
+    select.assert_awaited_with("TestVIN0000000001")

pysmarthashtag-0.13.0/pysmarthashtag/tests/test_ota_info.py

@@ -0,0 +1,73 @@
+"""Tests for OTA info fetching.
+
+The OTA endpoint is optional data, so its failures must never cost the
+session. In particular cloud code 1003 ("no OTA record for this VIN",
+observed on Smart #5) used to fall into the unmapped-code branch, which
+refreshed the authentication session on every single poll — 153 times in
+one day in the report — without ever clearing the 1003.
+"""
+
+import httpx
+import pytest
+import respx
+from httpx import Response
+
+from pysmarthashtag.account import SmartAccount
+from pysmarthashtag.const import OTA_SERVER_URL
+from pysmarthashtag.tests.conftest import prepare_account_with_vehicles
+
+_OTA_URL = OTA_SERVER_URL + "app/info/TestVIN0000000001"
+
+
+def _count_refreshes(account: SmartAccount) -> list[int]:
+    """Replace ``authentication.refresh`` with a counting no-op."""
+    calls: list[int] = []
+
+    async def fake_refresh() -> None:
+        calls.append(1)
+
+    account.config.authentication.refresh = fake_refresh
+    return calls
+
+
+@pytest.mark.asyncio
+async def test_ota_1003_returns_empty_without_refresh(smart_fixture: respx.Router) -> None:
+    """Code 1003 is normalised to "no OTA info" — no refresh, no retry."""
+    account = await prepare_account_with_vehicles()
+    refreshes = _count_refreshes(account)
+
+    route = smart_fixture.get(_OTA_URL).mock(
+        return_value=Response(200, json={"code": "1003", "message": "no ota info"})
+    )
+    # respx reuses the route registered by the fixture, so its counter already
+    # carries the OTA call made while setting the account up.
+    before = route.call_count
+
+    assert await account.get_vehicle_ota_info("TestVIN0000000001") == {}
+    assert refreshes == [], "1003 must not refresh the session"
+    assert route.call_count - before == 1, "1003 must not be retried"
+
+
+@pytest.mark.asyncio
+async def test_ota_1003_does_not_break_refresh_cycle(smart_fixture: respx.Router) -> None:
+    """A permanent 1003 still leaves every other vehicle sensor populated."""
+    smart_fixture.get(_OTA_URL).mock(return_value=Response(200, json={"code": "1003", "message": "no ota info"}))
+
+    account = await prepare_account_with_vehicles()
+
+    vehicle = account.vehicles["TestVIN0000000001"]
+    assert vehicle.vin == "TestVIN0000000001"
+    assert "ota" not in vehicle.data
+
+
+@pytest.mark.asyncio
+async def test_ota_unmapped_code_still_refreshes_once(smart_fixture: respx.Router) -> None:
+    """Regression guard: other unmapped codes keep the one-refresh remedy."""
+    account = await prepare_account_with_vehicles()
+    refreshes = _count_refreshes(account)
+
+    smart_fixture.get(_OTA_URL).mock(return_value=Response(200, json={"code": "9999", "message": "something new"}))
+
+    with pytest.raises(httpx.HTTPStatusError):
+        await account.get_vehicle_ota_info("TestVIN0000000001")
+    assert len(refreshes) == 1, "unmapped codes still get exactly one refresh"

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0}/pysmarthashtag/vehicle/vehicle.py

@@ -79,6 +79,9 @@ class SmartVehicle:
     journal_recording_control: Optional["JournalRecordingControl"] = None  # noqa: F821
     """Control for enabling/disabling on-vehicle trip recording."""
 
+    door_lock_control: Optional["DoorLockControl"] = None  # noqa: F821
+    """Control for remotely locking/unlocking the doors."""
+
     engine_state: Optional[str] = None
     """The state of the engine."""
 
@@ -163,6 +166,10 @@ class SmartVehicle:
 
         self.journal_recording_control = JournalRecordingControl(self.account, self.vin)
 
+        from pysmarthashtag.control.lock import DoorLockControl
+
+        self.door_lock_control = DoorLockControl(self.account, self.vin)
+
     def _parse_data(self) -> None:
         self.vin = self.data.get("vin")
         self.name = self.data.get("modelName")

{pysmarthashtag-0.12.2 → pysmarthashtag-0.13.0}/requirements-test.txt

@@ -7,7 +7,7 @@ black
 mypy
 types-setuptools
 pbr
-time_machine<3.4.0
+time_machine<3.6.0
 pre-commit
 backports.zoneinfo;python_version<"3.9"
-ruff==0.16.1
+ruff==0.16.9

pysmarthashtag-0.12.2/pySmartHashtag.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.12.2",
-  "distance": 0,
-  "node": "g800eaf2bed8475decf036d35ccdea3178897c327",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-15"
-}