pySmartHashtag 0.9.1__tar.gz → 0.9.2__tar.gz

{pysmarthashtag-0.9.1/pySmartHashtag.egg-info → pysmarthashtag-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pySmartHashtag
-Version: 0.9.1
+Version: 0.9.2
 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.9.1 → pysmarthashtag-0.9.2/pySmartHashtag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pySmartHashtag
-Version: 0.9.1
+Version: 0.9.2
 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.9.1 → pysmarthashtag-0.9.2}/pySmartHashtag.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ pysmarthashtag/api/ssl_context.py
 pysmarthashtag/api/utils.py
 pysmarthashtag/control/charging.py
 pysmarthashtag/control/climate.py
+pysmarthashtag/control/journal.py
 pysmarthashtag/tests/__init__.py
 pysmarthashtag/tests/common.py
 pysmarthashtag/tests/conftest.py
@@ -47,6 +48,8 @@ pysmarthashtag/tests/test_authentication_backoff.py
 pysmarthashtag/tests/test_charging.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_log_sanitizer.py
 pysmarthashtag/tests/test_missing_fields.py
 pysmarthashtag/tests/test_ssl_context.py
@@ -57,6 +60,8 @@ pysmarthashtag/tests/replys/auth_intermediate.url
 pysmarthashtag/tests/replys/auth_result.url
 pysmarthashtag/tests/replys/charging_success.json
 pysmarthashtag/tests/replys/climate_success.json
+pysmarthashtag/tests/replys/journal_response.json
+pysmarthashtag/tests/replys/journal_toggle_success.json
 pysmarthashtag/tests/replys/login_result.json
 pysmarthashtag/tests/replys/ota_response.json
 pysmarthashtag/tests/replys/soc_80.json
@@ -70,6 +75,7 @@ pysmarthashtag/tests/replys/vehicle_result.json
 pysmarthashtag/vehicle/__init__.py
 pysmarthashtag/vehicle/battery.py
 pysmarthashtag/vehicle/climate.py
+pysmarthashtag/vehicle/journal.py
 pysmarthashtag/vehicle/maintenance.py
 pysmarthashtag/vehicle/position.py
 pysmarthashtag/vehicle/running.py

{pysmarthashtag-0.9.1 → pysmarthashtag-0.9.2}/pysmarthashtag/account.py

@@ -41,6 +41,15 @@ class SmartAccount:
     vehicles: dict[str, SmartVehicle] = field(default_factory=dict, init=False)
     """Vehicles associated with the account."""
 
+    _journal_grant_cache: dict[str, str] = field(default_factory=dict, init=False)
+    """Per-VIN cache of the access_token under which the trip-journal
+    authorization grant was last accepted. ``{vin: access_token_string}``.
+    Used to skip the redundant grant POST when the same token is still
+    valid; auto-invalidates as soon as the token rotates (any reason —
+    expiry, manual relogin, future refresh-token flow). Maintained by
+    :meth:`grant_journal_authorization`.
+    """
+
     def __post_init__(self, password, log_responses):
         """Initialize the account."""
         # Ensure endpoint_urls is set
@@ -134,7 +143,24 @@ class SmartAccount:
             vehicle_info = await self.get_vehicle_information(vin)
             vehicle_soc = await self.get_vehicle_soc(vin)
             vehicle_ota_info = await self.get_vehicle_ota_info(vin)
-            vehicle.combine_data(vehicle_info, charging_settings=vehicle_soc, ota_info=vehicle_ota_info)
+            # Trip journal is best-effort: the endpoint can return 8153
+            # ("data unavailable") on vehicles where on-vehicle trip
+            # recording is OFF, or transiently when the per-session auth
+            # grant hasn't been accepted yet. Never let an empty journal
+            # fail the whole refresh.
+            journal_response = None
+            try:
+                journal_response = await self.get_trip_journal(vin)
+            except Exception:  # noqa: BLE001  # Best-effort: any failure (8153, transport, parse) must not break refresh.
+                _LOGGER.debug(
+                    "Trip journal fetch failed for %s", sanitize_log_data(vin), exc_info=True
+                )
+            vehicle.combine_data(
+                vehicle_info,
+                charging_settings=vehicle_soc,
+                ota_info=vehicle_ota_info,
+                journal_response=journal_response,
+            )
 
     async def select_active_vehicle(self, vin) -> None:
         """Select the active vehicle."""
@@ -257,6 +283,143 @@ class SmartAccount:
                 raise SmartAuthError("Could not get vehicle information")
         return data
 
+    async def grant_journal_authorization(self, vin, force: bool = False) -> bool:
+        """Grant cloud-side authorization for trip-journal data access.
+
+        ``POST /remote-control/user/authorization/insert`` with
+        ``{"serviceCode": "travelLogBusiCode", "authStatus": 1, "vin": <vin>}``.
+        This is a per-session handshake that unlocks the journalLogV4
+        endpoint — without it, journalLogV4 returns ``code: 8153``
+        ("data unavailable") even on vehicles where the on-vehicle
+        recording flag is set and trip data exists cloud-side.
+
+        Cached per-VIN per-access-token. The grant POST is observed to
+        rotate the access_token server-side (every poll without the cache
+        returns ``1402 token invalid`` on the next call, forcing a
+        re-login). The cache stores the access_token under which the
+        grant was accepted; subsequent calls under the *same* token
+        skip the redundant POST. The cache auto-invalidates as soon as
+        the token rotates (relogin, refresh, expiry — any reason).
+
+        Args:
+            vin: Vehicle identification number.
+            force: If True, ignore the cache and re-issue the grant.
+                Use this for explicit init flows where you want to be
+                certain the grant is fresh.
+
+        Returns:
+            True if the grant succeeded (or was already cached);
+            False if the POST failed.
+
+        """
+        token = self.config.authentication.api_access_token
+        if not force and token and self._journal_grant_cache.get(vin) == token:
+            _LOGGER.debug(
+                "Journal authorization cached for %s under current token; skipping POST",
+                sanitize_log_data(vin),
+            )
+            return True
+
+        _LOGGER.debug("Granting journal authorization for %s", sanitize_log_data(vin))
+        path = "/remote-control/user/authorization/insert"
+        body = json.dumps({"serviceCode": "travelLogBusiCode", "authStatus": 1, "vin": vin})
+        async with SmartClient(self.config) as client:
+            for retry in range(3):
+                try:
+                    r = await client.post(
+                        self.vehicles[vin].base_url + path,
+                        headers={
+                            **utils.generate_default_header(
+                                client.config.authentication.device_id,
+                                client.config.authentication.api_access_token,
+                                params={},
+                                method="POST",
+                                url=path,
+                                body=body,
+                            )
+                        },
+                        content=body.encode("utf-8"),
+                    )
+                    payload = r.json()
+                    success = bool(payload.get("success") or payload.get("code") == "1000")
+                    if success:
+                        # Record the token under which this grant was accepted.
+                        # Re-read after the POST since the server may have rotated
+                        # it during the call.
+                        self._journal_grant_cache[vin] = (
+                            self.config.authentication.api_access_token
+                        )
+                    return success
+                except SmartTokenRefreshNecessary:
+                    _LOGGER.debug("Token refresh needed during auth-grant retry %d", retry)
+                    continue
+                except SmartHumanCarConnectionError:
+                    _LOGGER.debug("Human-car connection error during auth-grant retry %d", retry)
+                    await self.select_active_vehicle(vin)
+                    continue
+                break
+        return False
+
+    async def get_trip_journal(self, vin, page_size: int = 20, window_days: int = 14) -> dict:
+        """Fetch the most recent trip-journal entries for a vehicle.
+
+        Hits ``/geelyTCAccess/tcservices/vehicle/status/journalLogV4/{vin}``
+        — the endpoint that carries server-side reverse-geocoded start/end
+        addresses alongside per-trip energy/distance/speed metrics.
+
+        Sends ``startTime`` / ``endTime`` (ms-epoch window), ``pageIndex``,
+        ``pageSize``, and ``userId`` as query params. The endpoint requires
+        a per-session authorization grant
+        (:meth:`grant_journal_authorization`), which this method calls
+        first; without it the endpoint returns ``code: 8153``. The grant
+        is cached per-VIN per-access-token, so subsequent calls under the
+        same token skip the grant POST.
+
+        Returns the raw response dict (with ``code``/``message``/``data``)
+        or an empty dict when the request fails server-side; raising is
+        avoided so a single flaky vehicle doesn't break the whole refresh.
+        """
+        await self.grant_journal_authorization(vin)
+        _LOGGER.debug("Getting trip journal for vehicle")
+        end_ms = int(datetime.datetime.now(datetime.timezone.utc).timestamp() * 1000)
+        start_ms = end_ms - window_days * 86400 * 1000
+        params = {
+            "endTime": str(end_ms),
+            "pageIndex": "1",
+            "pageSize": str(page_size),
+            "startTime": str(start_ms),
+            "userId": str(self.config.authentication.api_user_id),
+        }
+        path = "/geelyTCAccess/tcservices/vehicle/status/journalLogV4/" + vin
+        url = path + "?" + utils.join_url_params(params)
+        data: dict = {}
+        async with SmartClient(self.config) as client:
+            for retry in range(3):
+                try:
+                    r_journal = await client.get(
+                        self.vehicles[vin].base_url + url,
+                        headers={
+                            **utils.generate_default_header(
+                                client.config.authentication.device_id,
+                                client.config.authentication.api_access_token,
+                                params=params,
+                                method="GET",
+                                url=path,
+                            )
+                        },
+                    )
+                    _LOGGER.debug("Got response %d", r_journal.status_code)
+                    data = r_journal.json()
+                except SmartTokenRefreshNecessary:
+                    _LOGGER.debug("Got Token Error, retry: %d", retry)
+                    continue
+                except SmartHumanCarConnectionError:
+                    _LOGGER.debug("Got Human Car Connection Error, retry: %d", retry)
+                    await self.select_active_vehicle(vin)
+                    continue
+                break
+        return data
+
     async def get_vehicle_ota_info(self, vin) -> dict:
         """Get information about a vehicle from OTA server."""
         _LOGGER.debug("Getting OTA information for vehicle")

{pysmarthashtag-0.9.1 → pysmarthashtag-0.9.2}/pysmarthashtag/const.py

@@ -13,6 +13,7 @@ API_CARS_URL = "/device-platform/user/vehicle/secure"
 API_SESION_URL = "/auth/account/session/secure"
 API_SELECT_CAR_URL = "/device-platform/user/session/update"
 API_TELEMATICS_URL = "/remote-control/vehicle/telematics/"
+API_JOURNAL_TOGGLE_URL = "/remote-control/vehicle/status/journalLog/"
 
 OTA_SERVER_URL = "https://ota.srv.smart.com/"
 

{pysmarthashtag-0.9.1 → pysmarthashtag-0.9.2}/pysmarthashtag/control/climate.py

@@ -8,7 +8,7 @@ from typing import TypedDict
 from pysmarthashtag.account import SmartAccount
 from pysmarthashtag.api import utils
 from pysmarthashtag.api.client import SmartClient
-from pysmarthashtag.const import API_BASE_URL, API_TELEMATICS_URL
+from pysmarthashtag.const import API_TELEMATICS_URL
 from pysmarthashtag.models import SmartHumanCarConnectionError, SmartTokenRefreshNecessary
 
 _LOGGER = logging.getLogger(__name__)
@@ -112,7 +112,7 @@ class ClimateControll:
             for retry in range(3):
                 try:
                     vehicles_response = await client.put(
-                        API_BASE_URL + API_TELEMATICS_URL + self.vin,
+                        self.account.vehicles[self.vin].base_url + API_TELEMATICS_URL + self.vin,
                         headers={
                             **utils.generate_default_header(
                                 client.config.authentication.device_id,
@@ -133,3 +133,4 @@ class ClimateControll:
                 except SmartHumanCarConnectionError:
                     _LOGGER.debug("Got Human Car Connection Error, retry: %d", retry)
                     continue
+        return False

pysmarthashtag-0.9.2/pysmarthashtag/control/journal.py

@@ -0,0 +1,95 @@
+"""Provides client-side control of the vehicle's on-vehicle trip-recording flag.
+
+When the flag is OFF, the vehicle's TBox does not write to the cloud-side
+journal log, so ``SmartAccount.get_trip_journal()`` returns ``code:8153``
+"data unavailable". Toggling the flag ON causes subsequent trips to be
+written to the journal log, after which ``get_trip_journal()`` returns
+populated trip records.
+
+Modeled on ``pysmarthashtag.control.charging.ChargingControl``.
+"""
+
+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_JOURNAL_TOGGLE_URL
+from pysmarthashtag.models import SmartHumanCarConnectionError, SmartTokenRefreshNecessary
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class JournalRecordingControl:
+    """Toggle the on-vehicle trip-recording flag (``journalLogState``)."""
+
+    def __init__(self, account: SmartAccount, vin: str):
+        self.account = account
+        self.config = account.config
+        self.vin = vin
+
+    def _get_payload(self, enable: bool) -> str:
+        payload = {
+            "creator": "tc",
+            "timestamp": utils.create_correct_timestamp(),
+            "latest": False,
+            "command": "start" if enable else "stop",
+            "serviceId": "JOU",
+            "serviceParameters": [
+                {"key": "jou", "value": "enable" if enable else "disable"},
+            ],
+            "operationScheduling": {
+                "scheduledTime": 0,
+                "interval": 0,
+                "occurs": 0,
+                "recurrentOperation": True,
+                "duration": 60,
+            },
+        }
+        return json.dumps(payload, separators=(",", ":"))
+
+    async def enable_recording(self) -> bool:
+        """Turn on-vehicle trip recording ON."""
+        return await self._set_recording(enable=True)
+
+    async def disable_recording(self) -> bool:
+        """Turn on-vehicle trip recording OFF."""
+        return await self._set_recording(enable=False)
+
+    async def _set_recording(self, enable: bool) -> bool:
+        await self.account._ensure_ssl_context()
+        await self.account.select_active_vehicle(self.vin)
+
+        path = API_JOURNAL_TOGGLE_URL + self.vin
+        body = self._get_payload(enable)
+        action = "enable" if enable else "disable"
+        _LOGGER.debug("Setting trip-recording: %s", action)
+
+        async with SmartClient(self.config) as client:
+            for retry in range(3):
+                try:
+                    response = await client.put(
+                        self.account.vehicles[self.vin].base_url + path,
+                        headers={
+                            **utils.generate_default_header(
+                                client.config.authentication.device_id,
+                                client.config.authentication.api_access_token,
+                                params={},
+                                method="PUT",
+                                url=path,
+                                body=body,
+                            )
+                        },
+                        content=body.encode("utf-8"),
+                    )
+                    api_result = response.json()
+                    return bool(api_result.get("success"))
+                except SmartTokenRefreshNecessary:
+                    _LOGGER.debug("Got Token Error, retry: %d", retry)
+                    continue
+                except SmartHumanCarConnectionError:
+                    _LOGGER.debug("Got Human Car Connection Error, retry: %d", retry)
+                    await self.account.select_active_vehicle(self.vin)
+                    continue
+        return False

{pysmarthashtag-0.9.1 → pysmarthashtag-0.9.2}/pysmarthashtag/tests/common.py

@@ -1,5 +1,7 @@
 """Fixtures for Smart tests."""
 
+import re
+
 import respx
 
 from pysmarthashtag.const import (
@@ -105,6 +107,40 @@ class SmartMockRouter(respx.MockRouter):
                 200,
                 json=load_response(RESPONSE_DIR / "soc_90.json"),
             )
+            # journalLogV4 takes endTime/startTime/pageIndex/pageSize/userId
+            # query params; respx matches by URL prefix without query when
+            # we use route() with `host=` + `path__startswith=`. Keep
+            # URL-prefix matching simple by registering with a regex.
+            self.get(re.compile(re.escape(
+                base_url + "/geelyTCAccess/tcservices/vehicle/status/journalLogV4/TestVIN0000000001"
+            ) + r".*")).respond(
+                200,
+                json=load_response(RESPONSE_DIR / "journal_response.json"),
+            )
+            self.get(re.compile(re.escape(
+                base_url + "/geelyTCAccess/tcservices/vehicle/status/journalLogV4/TestVIN0000000002"
+            ) + r".*")).respond(
+                200,
+                json=load_response(RESPONSE_DIR / "journal_response.json"),
+            )
+            # Auth-grant handshake (called before each get_trip_journal)
+            self.post(base_url + "/remote-control/user/authorization/insert").respond(
+                200,
+                json={
+                    "code": "1000",
+                    "data": {"serviceCode": "travelLogBusiCode", "authStatus": 1},
+                    "success": True,
+                    "message": "operation succeed",
+                },
+            )
+            self.put(base_url + "/remote-control/vehicle/status/journalLog/TestVIN0000000001").respond(
+                200,
+                json=load_response(RESPONSE_DIR / "journal_toggle_success.json"),
+            )
+            self.put(base_url + "/remote-control/vehicle/status/journalLog/TestVIN0000000002").respond(
+                200,
+                json=load_response(RESPONSE_DIR / "journal_toggle_success.json"),
+            )
 
         self.get(OTA_SERVER_URL + "app/info/TestVIN0000000001").respond(
             200,

pysmarthashtag-0.9.2/pysmarthashtag/tests/replys/journal_response.json

@@ -0,0 +1,52 @@
+{
+  "code": "1000",
+  "message": "operation succeed",
+  "success": true,
+  "data": {
+    "pagination": {
+      "pageIndex": 1,
+      "sortField": "startTime",
+      "start": 1,
+      "pageSize": 20,
+      "totleSize": 42,
+      "direction": "desc"
+    },
+    "list": [
+      {
+        "tripId": 1734246000,
+        "startTime": 1734246000000,
+        "endTime": 1734247230000,
+        "startOdometer": 2950.0,
+        "endOdometer": 2965.4,
+        "traveledDistance": 15.4,
+        "avgSpeed": 45.0,
+        "electricConsumption": 20.8,
+        "tripStartAddr": "123 Test Street, Test City",
+        "tripEndAddr": "15 Other Road, Test City",
+        "tripRemark": null,
+        "tripLabel": null,
+        "trackpoints": [
+          {"position": {"altitude": 27, "latitude": 217414695, "longitude": 80626712, "posCanBeTrusted": true, "marsCoordinates": false}},
+          {"position": {"altitude": 28, "latitude": 217384510, "longitude": 80573036, "posCanBeTrusted": true, "marsCoordinates": false}}
+        ],
+        "regeneratedEnergy": 0.8
+      },
+      {
+        "tripId": 1734200000,
+        "startTime": 1734200000000,
+        "endTime": 1734200600000,
+        "startOdometer": 2942.9,
+        "endOdometer": 2950.0,
+        "traveledDistance": 7.1,
+        "avgSpeed": 40.0,
+        "electricConsumption": 21.1,
+        "tripStartAddr": "9 Elsewhere Ave, Test City",
+        "tripEndAddr": "123 Test Street, Test City",
+        "tripRemark": null,
+        "tripLabel": null,
+        "trackpoints": [],
+        "regeneratedEnergy": 0.3
+      }
+    ]
+  }
+}

pysmarthashtag-0.9.2/pysmarthashtag/tests/replys/journal_toggle_success.json

@@ -0,0 +1,9 @@
+{
+  "code": "1000",
+  "data": {},
+  "success": true,
+  "hint": null,
+  "httpStatus": "OK",
+  "sessionId": "test-session-journal-toggle",
+  "message": "operation succeed"
+}