pySmartHashtag 0.9.0__tar.gz → 0.9.2__tar.gz

{pysmarthashtag-0.9.0 → pysmarthashtag-0.9.2}/.devcontainer.json

@@ -24,4 +24,4 @@
     }
   },
   "remoteUser": "vscode"
-}
+}

{pysmarthashtag-0.9.0 → pysmarthashtag-0.9.2}/.github/copilot-instructions.md

@@ -61,6 +61,7 @@ pre-commit run --all-files
 ### Ruff Configuration
 
 The project uses ruff with the following rule sets:
+
 - C (complexity)
 - D (docstrings)
 - E (pycodestyle)
@@ -116,6 +117,7 @@ async def example_method(self) -> dict:
 ## Error Handling
 
 Use the custom exception classes defined in `models.py`:
+
 - `SmartAuthError` - Authentication failures
 - `SmartTokenRefreshNecessary` - Token refresh required
 - `SmartHumanCarConnectionError` - Human-car connection issues
@@ -136,11 +138,13 @@ Use `sanitize_log_data()` from `api.log_sanitizer` when logging sensitive data.
 ## Dependencies
 
 Main dependencies:
+
 - `httpx` - Async HTTP client
 - `pycryptodome` - Cryptographic functions
 - `pyjwt` - JWT token handling
 
 Test dependencies:
+
 - `pytest`, `pytest-asyncio`, `pytest-cov`
 - `respx` - HTTP mocking
 - `ruff` - Linting and formatting

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pySmartHashtag
-Version: 0.9.0
+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.0 → 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.0 → pysmarthashtag-0.9.2}/pysmarthashtag/__init__.py

@@ -2,7 +2,6 @@
 
 from importlib.metadata import PackageNotFoundError, version
 
-
 try:
     __version__ = version("pySmartHashtag")
 except PackageNotFoundError:

{pysmarthashtag-0.9.0 → 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")