pySmartHashtag 0.9.2__tar.gz → 0.11.0__tar.gz

{pysmarthashtag-0.9.2 → pysmarthashtag-0.11.0}/.github/workflows/python-package.yml

@@ -24,6 +24,8 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4.1.1
+        with:
+          fetch-depth: 0
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:

{pysmarthashtag-0.9.2 → pysmarthashtag-0.11.0}/.github/workflows/python-publish.yml

@@ -21,6 +21,8 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4.1.1
+        with:
+          fetch-depth: 0
       - name: Set up Python
         uses: actions/setup-python@v5
         with:

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

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

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

@@ -50,9 +50,12 @@ 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_log_sanitizer.py
 pysmarthashtag/tests/test_missing_fields.py
 pysmarthashtag/tests/test_ssl_context.py
+pysmarthashtag/tests/test_trackpoints.py
+pysmarthashtag/tests/test_vehicle_state.py
 pysmarthashtag/tests/replys/Human_and_vehicle_relationship_does_not_exist.json
 pysmarthashtag/tests/replys/api_access.json
 pysmarthashtag/tests/replys/auth_context.url
@@ -67,6 +70,7 @@ pysmarthashtag/tests/replys/ota_response.json
 pysmarthashtag/tests/replys/soc_80.json
 pysmarthashtag/tests/replys/soc_90.json
 pysmarthashtag/tests/replys/token_expired.json
+pysmarthashtag/tests/replys/trackpoints_response.json
 pysmarthashtag/tests/replys/vehicle_info.json
 pysmarthashtag/tests/replys/vehicle_info2.json
 pysmarthashtag/tests/replys/vehicle_info_dc_charging.json
@@ -81,4 +85,6 @@ pysmarthashtag/vehicle/position.py
 pysmarthashtag/vehicle/running.py
 pysmarthashtag/vehicle/safety.py
 pysmarthashtag/vehicle/tires.py
-pysmarthashtag/vehicle/vehicle.py
+pysmarthashtag/vehicle/trackpoints.py
+pysmarthashtag/vehicle/vehicle.py
+pysmarthashtag/vehicle/vehicle_state.py

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

@@ -1,24 +1,108 @@
 """Access to Smart account for your vehicles therin."""
 
+import asyncio
 import datetime
 import json
 import logging
 from dataclasses import InitVar, dataclass, field
 from typing import Optional
 
+import httpx
+
 from pysmarthashtag.api import utils
 from pysmarthashtag.api.authentication import SmartAuthentication
 from pysmarthashtag.api.client import SmartClient, SmartClientConfiguration
 from pysmarthashtag.api.log_sanitizer import sanitize_log_data
 from pysmarthashtag.const import API_CARS_URL, API_SELECT_CAR_URL, EndpointUrls
-from pysmarthashtag.models import SmartAuthError, SmartHumanCarConnectionError, SmartTokenRefreshNecessary
+from pysmarthashtag.models import (
+    JournalTruncationError,
+    SmartAuthError,
+    SmartHumanCarConnectionError,
+    SmartTokenRefreshNecessary,
+)
+from pysmarthashtag.vehicle.trackpoints import TripTrackpoints, parse_trackpoints_response
 from pysmarthashtag.vehicle.vehicle import SmartVehicle
 
+# Path prefix for the per-trip GPS trackpoints endpoint. Cloud-side
+# service is ``vehicle-history-service / journal-service`` (same
+# ``apiv2.ecloudeu.com`` host as journalLogV4); the trailing ``history``
+# segment is the cloud's own naming.
+TRIP_TRACKPOINTS_PATH_PREFIX = "/vehicle-history-service/journal-service/vehicle/status/history/"
+
+# Default page size for the trackpoints endpoint, matching the cap the
+# cloud advertises in its own ``pagination`` block. In observed responses
+# ``totleSize`` never exceeded this cap; the wrapper logs a WARNING if it
+# ever does so a future maintainer knows to add pagination here.
+TRIP_TRACKPOINTS_PAGE_SIZE = 500
+
+# Cloud status code returned by both journalLogV4 and the trackpoints
+# endpoint when there's no data to report. The SDK raises
+# :class:`httpx.HTTPStatusError` for any non-1000 code with a
+# ``message`` key; 8153 surfaces here so callers can normalise it to an
+# empty result without propagating to the caller.
+_BENIGN_EMPTY_CODE = "8153"
+
 VALID_UNTIL_OFFSET = datetime.timedelta(seconds=10)
 
+# Cloud's "data unavailable" code on the journal endpoints. The SDK's
+# raise_for_status hook surfaces it as :class:`httpx.HTTPStatusError`;
+# the page-loop normalises it to "end of data" so a transient cloud
+# blip mid-loop doesn't fail the whole poll.
+_BENIGN_EMPTY_CODE = "8153"
+
 _LOGGER = logging.getLogger(__name__)
 
 
+def _is_benign_empty(exc: httpx.HTTPStatusError) -> bool:
+    """Return True iff ``exc`` carries the cloud's 8153 "data unavailable" code.
+
+    The SDK's :func:`raise_for_status_event_handler` raises for any
+    non-1000 ``code`` with a ``message`` key. ``8153`` is the cloud's
+    end-of-data signal for journal endpoints — callers normalise it to
+    an empty result rather than propagating it as an error.
+    """
+    response = exc.response
+    if response is None:
+        return False
+    try:
+        body = response.json()
+    except ValueError:
+        return False
+    return str(body.get("code")) == _BENIGN_EMPTY_CODE
+
+
+def _unwrap_journal_page(body: dict) -> tuple[list, Optional[int]]:
+    """Pull ``data.list`` and ``data.pagination.totleSize`` out of a journal body.
+
+    Returns ``([], None)`` for missing/None ``data`` (the cloud
+    occasionally returns a top-level ``code: 1000`` with ``data: null``
+    on empty windows, which we treat as a benign empty page).
+
+    The cloud's response envelope uses the typo "totleSize" (sic) for
+    the total-records field — preserve the misspelling so the existing
+    parser keeps working.
+    """
+    if not isinstance(body, dict):
+        return [], None
+    data = body.get("data")
+    if not isinstance(data, dict):
+        return [], None
+    items_raw = data.get("list")
+    items = items_raw if isinstance(items_raw, list) else []
+    pagination = data.get("pagination")
+    total_raw = pagination.get("totleSize") if isinstance(pagination, dict) else None
+    if isinstance(total_raw, bool):
+        # bool is an int subclass — guard so True/False never become 1/0.
+        total = None
+    elif isinstance(total_raw, (int, float)):
+        total = int(total_raw)
+    elif isinstance(total_raw, str) and total_raw.strip().isdigit():
+        total = int(total_raw.strip())
+    else:
+        total = None
+    return list(items), total
+
+
 @dataclass
 class SmartAccount:
     """Create a new connection to the Smart web service."""
@@ -155,11 +239,21 @@ class SmartAccount:
                 _LOGGER.debug(
                     "Trip journal fetch failed for %s", sanitize_log_data(vin), exc_info=True
                 )
+            # Per-VIN TBox state flags (engine/journal/valet/etc.) — best-effort,
+            # same reasoning as the journal call above.
+            state_response = None
+            try:
+                state_response = await self.get_vehicle_state(vin)
+            except Exception:  # noqa: BLE001  # Best-effort: state fetch must not break refresh.
+                _LOGGER.debug(
+                    "Vehicle-state 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,
+                state_response=state_response,
             )
 
     async def select_active_vehicle(self, vin) -> None:
@@ -242,6 +336,47 @@ class SmartAccount:
                 raise SmartAuthError("Could not get vehicle information")
         return data
 
+    async def get_vehicle_state(self, vin) -> dict:
+        """Fetch the small flat-dict state-flag response for a vehicle.
+
+        Hits ``/remote-control/vehicle/status/state/{vin}`` (no params) —
+        the same endpoint Hello # uses to confirm command dispatch (e.g.
+        polls ``journalLogState`` after toggling 'Record trips on vehicle').
+
+        Returns the raw response dict; caller wraps via
+        ``VehicleState.from_response()``. Errors are logged but not raised
+        so a single flaky vehicle doesn't break the wider refresh.
+        """
+        _LOGGER.debug("Getting vehicle state for %s", sanitize_log_data(vin))
+        path = "/remote-control/vehicle/status/state/" + vin
+        data: dict = {}
+        async with SmartClient(self.config) as client:
+            for retry in range(3):
+                try:
+                    r_state = await client.get(
+                        self.vehicles[vin].base_url + path,
+                        headers={
+                            **utils.generate_default_header(
+                                client.config.authentication.device_id,
+                                client.config.authentication.api_access_token,
+                                params={},
+                                method="GET",
+                                url=path,
+                            )
+                        },
+                    )
+                    _LOGGER.debug("Got response %d", r_state.status_code)
+                    data = r_state.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_soc(self, vin) -> str:
         """Get information about a vehicle."""
         _LOGGER.debug("Getting vehicle SOC")
@@ -360,8 +495,15 @@ class SmartAccount:
                 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.
+    async def get_trip_journal(
+        self,
+        vin,
+        page_size: int = 20,
+        window_days: int = 14,
+        raise_on_truncation: bool = False,
+        page_gap_seconds: float = 0.0,
+    ) -> dict:
+        """Fetch trip-journal entries for a vehicle, page-looping ``pageIndex=1..N``.
 
         Hits ``/geelyTCAccess/tcservices/vehicle/status/journalLogV4/{vin}``
         — the endpoint that carries server-side reverse-geocoded start/end
@@ -375,17 +517,142 @@ class SmartAccount:
         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.
+        Page-loops ``pageIndex=2, 3, ...`` until **either** the
+        cloud-reported ``totleSize`` is reached **or** the previous page
+        came back short (the cloud's "no more pages" signal — fewer rows
+        than the requested ``page_size``). Accounts with more trips in
+        the window than ``page_size`` no longer silently lose the tail.
+
+        A ``code=8153`` mid-loop is treated as end-of-data and breaks
+        the loop with whatever's accumulated; the first page's 8153
+        still propagates as :class:`httpx.HTTPStatusError` so callers
+        with their own benign-empty handling (e.g. :meth:`get_vehicles`)
+        keep working unchanged.
+
+        After the loop, if the accumulated count disagrees with the
+        cloud's ``totleSize``:
+
+        * with ``raise_on_truncation=False`` (default), logs a WARNING
+          with both numbers and returns the partial accumulated dict —
+          routine polls keep going so the next iteration can pick up
+          the missing trips.
+        * with ``raise_on_truncation=True``, raises
+          :class:`pysmarthashtag.models.JournalTruncationError` instead.
+          Used by backfill/archive callers where silent data loss is
+          worse than a hard failure that forces an operator to look.
+
+        ``page_gap_seconds`` lets callers insert a polite-API sleep
+        between successive page fetches (default 0.0 — the SDK has no
+        opinion; consumers that want one set their own).
+
+        Returns a dict with the same shape as the cloud's first-page
+        response (``code`` / ``message`` / ``data``) but with
+        ``data.list`` containing the merged entries from every page.
+        ``data.pagination.totleSize`` carries the cloud's most recent
+        report. Returns an empty dict only when the page-1 request
+        itself fails server-side (preserved from the prior single-page
+        behaviour so a single flaky vehicle doesn't break the 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
+
+        first = await self._fetch_journal_page(vin, 1, page_size, start_ms, end_ms)
+        if not first:
+            return {}
+
+        accumulated, total = _unwrap_journal_page(first)
+        if not accumulated:
+            return first
+        last_page_count = len(accumulated)
+
+        page_index = 2
+        while True:
+            # Stop conditions before issuing another request:
+            # - cloud-reported total has been reached/exceeded, OR
+            # - the previous page came back short (cloud's "no more
+            #   pages" signal — fewer rows than requested).
+            if total is not None and len(accumulated) >= total:
+                break
+            if last_page_count < page_size:
+                break
+
+            if page_gap_seconds > 0:
+                await asyncio.sleep(page_gap_seconds)
+
+            try:
+                page = await self._fetch_journal_page(
+                    vin, page_index, page_size, start_ms, end_ms
+                )
+            except httpx.HTTPStatusError as exc:
+                if _is_benign_empty(exc):
+                    _LOGGER.debug(
+                        "journalLogV4 returned 8153 mid-loop for %s at page %d; treating as end-of-data",
+                        sanitize_log_data(vin),
+                        page_index,
+                    )
+                    break
+                raise
+
+            page_items, page_total = _unwrap_journal_page(page)
+            if page_total is not None:
+                total = page_total
+            if not page_items:
+                break
+            accumulated.extend(page_items)
+            last_page_count = len(page_items)
+            page_index += 1
+
+        if total is not None and total != len(accumulated):
+            if raise_on_truncation:
+                raise JournalTruncationError(
+                    f"page-loop for {sanitize_log_data(vin)} accumulated "
+                    f"{len(accumulated)} items but cloud reported "
+                    f"totleSize={total}; aborting rather than silently "
+                    "returning an incomplete history"
+                )
+            _LOGGER.warning(
+                "Journal page-loop truncation for %s: accumulated %d items "
+                "but cloud reported totleSize=%d. Possible silent data loss — "
+                "investigate page-loop termination.",
+                sanitize_log_data(vin),
+                len(accumulated),
+                total,
+            )
+
+        # Rebuild the response shape with the merged list and the
+        # final totleSize so consumers parsing ``data.list`` see all
+        # pages without needing to know there was a loop.
+        merged = dict(first)
+        merged_data = dict(merged.get("data") or {})
+        merged_data["list"] = accumulated
+        if total is not None:
+            merged_pagination = dict(merged_data.get("pagination") or {})
+            merged_pagination["totleSize"] = total
+            merged_data["pagination"] = merged_pagination
+        merged["data"] = merged_data
+        return merged
+
+    async def _fetch_journal_page(
+        self,
+        vin: str,
+        page_index: int,
+        page_size: int,
+        start_ms: int,
+        end_ms: int,
+    ) -> dict:
+        """Fetch a single page of journalLogV4 for ``vin``.
+
+        Mirrors the request construction the previous single-page
+        :meth:`get_trip_journal` did, parameterised by ``page_index``.
+        The auth-grant POST is NOT issued here — the caller does it
+        once before the loop, since the cache short-circuits subsequent
+        fetches under the same token anyway.
+        """
         params = {
             "endTime": str(end_ms),
-            "pageIndex": "1",
+            "pageIndex": str(page_index),
             "pageSize": str(page_size),
             "startTime": str(start_ms),
             "userId": str(self.config.authentication.api_user_id),
@@ -396,7 +663,7 @@ class SmartAccount:
         async with SmartClient(self.config) as client:
             for retry in range(3):
                 try:
-                    r_journal = await client.get(
+                    response = await client.get(
                         self.vehicles[vin].base_url + url,
                         headers={
                             **utils.generate_default_header(
@@ -408,8 +675,8 @@ class SmartAccount:
                             )
                         },
                     )
-                    _LOGGER.debug("Got response %d", r_journal.status_code)
-                    data = r_journal.json()
+                    _LOGGER.debug("Got response %d", response.status_code)
+                    data = response.json()
                 except SmartTokenRefreshNecessary:
                     _LOGGER.debug("Got Token Error, retry: %d", retry)
                     continue
@@ -420,6 +687,103 @@ class SmartAccount:
                 break
         return data
 
+    async def get_trip_trackpoints(
+        self,
+        vin: str,
+        start_time_ms: int,
+        end_time_ms: int,
+        page_size: int = TRIP_TRACKPOINTS_PAGE_SIZE,
+    ) -> TripTrackpoints:
+        """Fetch the per-trip GPS trackpoints for one finished trip.
+
+        Hits ``/vehicle-history-service/journal-service/vehicle/status/history/{vin}``
+        on the same host as journalLogV4, with the ``(startTime, endTime)``
+        window identifying the trip (the cloud has no separate trip-id
+        for this endpoint — the time window IS the identifier).
+
+        Unlike :meth:`get_trip_journal`, this endpoint does NOT require
+        :meth:`grant_journal_authorization` — calling that defensively
+        before each fetch would burn an extra cloud round-trip per trip.
+        The minimum required flow is auth (already done by
+        :meth:`get_vehicles` at session startup) plus the single signed
+        ``GET`` to ``/.../history/{VIN}``.
+
+        Cloud direction is ``desc`` (newest-first); the returned
+        :attr:`TripTrackpoints.points` are reversed to chronological
+        order so callers don't need to know the wire format.
+
+        Three benign-empty cloud responses all map to
+        ``TripTrackpoints(points=[], total_size=0)``:
+
+        * ``code: "1000"`` with ``data.list = []``
+        * ``code: "1000"`` with ``data: null``
+        * ``code: "8153"`` ("data unavailable" — surfaces as
+          :class:`httpx.HTTPStatusError` from the SDK)
+
+        Other ``HTTPStatusError`` exceptions (cloud 5xx, network,
+        non-1402 auth failure) propagate up so the caller can decide
+        whether to retry or surface the error.
+
+        Pagination is intentionally NOT implemented: the cloud's own
+        ``pagination`` block reports ``pageSize=500`` as the cap, and in
+        observed responses ``totleSize`` never exceeded it. If a future
+        trip ever does, this method logs a WARNING so we know to revisit.
+        """
+        _LOGGER.debug("Getting trip trackpoints for vehicle")
+        params = {
+            "endTime": str(end_time_ms),
+            "pageIndex": "0",
+            "pageSize": str(page_size),
+            "source": "tc",
+            "startTime": str(start_time_ms),
+        }
+        path = TRIP_TRACKPOINTS_PATH_PREFIX + vin
+        url = path + "?" + utils.join_url_params(params)
+        async with SmartClient(self.config) as client:
+            for retry in range(3):
+                try:
+                    response = 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", response.status_code)
+                    body = response.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
+                except httpx.HTTPStatusError as exc:
+                    if _is_benign_empty(exc):
+                        _LOGGER.debug(
+                            "trackpoints endpoint returned 8153 (data unavailable) for %s; treating as empty",
+                            sanitize_log_data(vin),
+                        )
+                        return TripTrackpoints(points=[], total_size=0)
+                    raise
+                break
+        trackpoints = parse_trackpoints_response(body)
+        if trackpoints.total_size > page_size:
+            _LOGGER.warning(
+                "Trackpoints page-size cap exceeded for %s: totleSize=%d > pageSize=%d. "
+                "Wrapper does not loop pageIndex; returned points are the head only. "
+                "Add pagination if this fires for real trips.",
+                sanitize_log_data(vin),
+                trackpoints.total_size,
+                page_size,
+            )
+        return trackpoints
+
     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.2 → pysmarthashtag-0.11.0}/pysmarthashtag/models.py

@@ -96,6 +96,19 @@ class SmartRemoteServiceError(SmartAPIError):
     """Error when executing web services."""
 
 
+class JournalTruncationError(SmartAPIError):
+    """Page-loop accumulated count disagreed with the cloud-reported total.
+
+    Raised by :meth:`pysmarthashtag.account.SmartAccount.get_trip_journal`
+    when ``raise_on_truncation=True`` and the merged page-loop ended with
+    ``len(data.list) != totleSize``. The default of ``raise_on_truncation
+    =False`` instead logs a WARNING — routine polls keep going so the
+    next iteration can pick up the missing trips. Backfill / archive
+    callers can opt into the hard failure: a backfill that silently lost
+    data is worse than one that aborts and forces investigation.
+    """
+
+
 def get_element_from_dict_maybe(
     data: dict, *path: str, default: "Any|None" = None
 ) -> Optional[Union[dict, str, int, float]]:

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

@@ -107,6 +107,22 @@ class SmartMockRouter(respx.MockRouter):
                 200,
                 json=load_response(RESPONSE_DIR / "soc_90.json"),
             )
+            # Per-trip GPS-trackpoints endpoint takes
+            # endTime/startTime/pageIndex/pageSize/source query params.
+            # Match by regex prefix so the route fires regardless of
+            # param values.
+            self.get(re.compile(re.escape(
+                base_url + "/vehicle-history-service/journal-service/vehicle/status/history/TestVIN0000000001"
+            ) + r".*")).respond(
+                200,
+                json=load_response(RESPONSE_DIR / "trackpoints_response.json"),
+            )
+            self.get(re.compile(re.escape(
+                base_url + "/vehicle-history-service/journal-service/vehicle/status/history/TestVIN0000000002"
+            ) + r".*")).respond(
+                200,
+                json=load_response(RESPONSE_DIR / "trackpoints_response.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

pysmarthashtag-0.11.0/pysmarthashtag/tests/replys/trackpoints_response.json

@@ -0,0 +1,20 @@
+{
+  "code": "1000",
+  "message": null,
+  "data": {
+    "pagination": {
+      "pageIndex": 1,
+      "sortField": "startTime",
+      "start": 1,
+      "pageSize": 500,
+      "totleSize": 4,
+      "direction": "desc"
+    },
+    "list": [
+      {"basicVehicleStatus": {"position": {"latitude": 217471769, "longitude": 80503026}}},
+      {"basicVehicleStatus": {"position": {"latitude": 217470945, "longitude": 80502024}}},
+      {"basicVehicleStatus": {"position": {"latitude": 217469078, "longitude": 80504125}}},
+      {"basicVehicleStatus": {"position": {"latitude": 217468000, "longitude": 80505500}}}
+    ]
+  }
+}