lapviz 1.0.0__py3-none-any.whl

lapviz/__init__.py

@@ -0,0 +1,26 @@
+"""LapViz API client for Python: https://lapviz.com/developers/docs"""
+
+__version__ = "1.0.0"
+
+from .client import LapViz  # noqa: E402
+from .errors import (  # noqa: E402
+    AuthenticationError,
+    LapVizError,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
+)
+from .webhooks import EVENT_HEADER, SIGNATURE_HEADER, compute_signature, verify_signature  # noqa: E402
+
+__all__ = [
+    "LapViz",
+    "LapVizError",
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "NotFoundError",
+    "RateLimitError",
+    "verify_signature",
+    "compute_signature",
+    "SIGNATURE_HEADER",
+    "EVENT_HEADER",
+]

lapviz/client.py

@@ -0,0 +1,388 @@
+"""Client of the LapViz API (https://lapviz.com/developers/docs), with the Python standard library only.
+
+Responses are returned as the JSON of the API (dicts with camelCase keys, as in the reference): fields added to the API
+appear without a new version of this package.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from datetime import date, datetime
+from typing import Any, BinaryIO, Dict, Iterator, List, Optional, Tuple, Union
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
+
+from . import __version__
+from .errors import LapVizError, RateLimitError, error_for
+
+DEFAULT_BASE_URL = "https://lapviz.com"
+JSON = Any
+PathLike = Union[str, "os.PathLike[str]"]
+
+
+def _segment(value: Any) -> str:
+    """One segment of a path: "users/1-A" becomes "users%2F1-A"."""
+    return quote(str(value), safe="")
+
+
+def _camel(name: str) -> str:
+    name = name.rstrip("_")  # from_ (a keyword in Python) is "from"
+    head, *rest = name.split("_")
+    return head + "".join(x[:1].upper() + x[1:] for x in rest)
+
+
+def _body(values: Dict[str, Any]) -> Dict[str, Any]:
+    """Keyword arguments as a JSON body: camelCase names, dates in ISO 8601, None left out."""
+    result = {}
+    for name, value in values.items():
+        if value is None:
+            continue
+        if isinstance(value, (datetime, date)):
+            value = value.isoformat()
+        result[_camel(name)] = value
+    return result
+
+
+class LapViz:
+    """Client of the LapViz API.
+
+    ``LapViz()`` reads the key from the ``LAPVIZ_API_KEY`` environment variable; ``LapViz(api_key="lvz_...")`` takes
+    it directly, ``LapViz(access_token="lvzat_...")`` uses an OAuth access token ("Sign in with LapViz") instead.
+    Anonymous calls (the circuits, the public sessions) need neither.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        access_token: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 60,
+        max_retries: int = 2,
+        user_agent: Optional[str] = None,
+    ):
+        self.api_key = api_key if api_key is not None else (None if access_token else os.environ.get("LAPVIZ_API_KEY") or None)
+        self.access_token = access_token
+        self.base_url = base_url.rstrip("/")
+        if self.base_url.endswith("/api"):
+            self.base_url = self.base_url[:-4]
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.user_agent = user_agent or f"lapviz-python/{__version__}"
+        self.rate_limit: Dict[str, str] = {}
+        """The RateLimit-* headers of the last response (Limit, Remaining, Policy)."""
+
+        self.account = Account(self)
+        self.sessions = Sessions(self)
+        self.imports = Imports(self)
+        self.teams = Teams(self)
+        self.webhooks = Webhooks(self)
+        self.circuits = Circuits(self)
+
+    def me(self) -> JSON:
+        """The account of the key or token: the first call to make with a new key."""
+        return self.account.me()
+
+    # Transport
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: Any = None,
+        query: Optional[Dict[str, Any]] = None,
+        data: Optional[bytes] = None,
+        headers: Optional[Dict[str, str]] = None,
+        stream_to: Optional[BinaryIO] = None,
+    ) -> JSON:
+        """Calls any operation of the API, e.g. ``request("GET", "api/session/vehicles")``; returns the JSON of the
+        answer (None when it has no body), or writes it to ``stream_to``. Retries on 429 and 503 after Retry-After."""
+        url = f"{self.base_url}/{path.lstrip('/')}"
+        query = {k: v for k, v in (query or {}).items() if v is not None}
+        if query:
+            url += "?" + urlencode({k: (str(v).lower() if isinstance(v, bool) else v) for k, v in query.items()})
+
+        all_headers = {"Accept": "application/json", "User-Agent": self.user_agent}
+        if self.api_key:
+            all_headers["X-Api-Key"] = self.api_key
+        elif self.access_token:
+            all_headers["Authorization"] = f"Bearer {self.access_token}"
+        if json_body is not None:
+            data = json.dumps(json_body).encode("utf-8")
+            all_headers["Content-Type"] = "application/json"
+        all_headers.update(headers or {})
+
+        attempt = 0
+        while True:
+            try:
+                with urlopen(Request(url, data=data, headers=all_headers, method=method), timeout=self.timeout) as response:
+                    self._remember_rate_limit(response.headers)
+                    if stream_to is not None:
+                        while True:
+                            chunk = response.read(1 << 16)
+                            if not chunk:
+                                return None
+                            stream_to.write(chunk)
+                    content = response.read()
+                    if not content:
+                        return None
+                    if "json" in (response.headers.get("Content-Type") or ""):
+                        return json.loads(content)
+                    return content.decode("utf-8", errors="replace")
+            except HTTPError as error:
+                self._remember_rate_limit(error.headers)
+                retry_after = _retry_after(error.headers.get("Retry-After"))
+                content = error.read()
+                try:
+                    body: Any = json.loads(content) if content else None
+                except ValueError:
+                    body = content.decode("utf-8", errors="replace")
+                if error.code in (429, 503) and attempt < self.max_retries:
+                    attempt += 1
+                    time.sleep(min(retry_after if retry_after is not None else 2 ** attempt, 60))
+                    continue
+                raise error_for(error.code, body, retry_after) from None
+            except URLError as error:
+                raise LapVizError(0, "Connection failed", str(error.reason)) from None
+
+    def _remember_rate_limit(self, headers: Any) -> None:
+        values = {name[len("RateLimit-"):]: headers.get(name) for name in ("RateLimit-Limit", "RateLimit-Remaining", "RateLimit-Policy")}
+        if any(values.values()):
+            self.rate_limit = {k: v for k, v in values.items() if v is not None}
+
+    def _download(self, path: str, output: PathLike, query: Optional[Dict[str, Any]] = None) -> str:
+        output = os.fspath(output)
+        partial = output + ".part"
+        try:
+            with open(partial, "wb") as file:
+                self.request("GET", path, query=query, headers={"Accept": "*/*"}, stream_to=file)
+            os.replace(partial, output)
+        finally:
+            if os.path.exists(partial):
+                os.remove(partial)
+        return output
+
+
+def _retry_after(value: Optional[str]) -> Optional[float]:
+    try:
+        return max(0.0, float(value)) if value else None
+    except ValueError:
+        return None
+
+
+class _Resource:
+    def __init__(self, client: LapViz):
+        self._client = client
+
+
+class Account(_Resource):
+    """The authenticated account and the public driver cards."""
+
+    def me(self) -> JSON:
+        return self._client.request("GET", "api/users/me")
+
+    def driver_card(self, user_id: str) -> JSON:
+        """Driver card of an account ("users/1-A"): someone else's only when their profile is public."""
+        return self._client.request("GET", f"api/users/info/{_segment(user_id)}")
+
+
+class Sessions(_Resource):
+    """Lap timing sessions: search, read, change, delete, export, telemetry and the change feed of the library."""
+
+    def search(self, *, page: int = 1, page_size: int = 20, **filters: Any) -> JSON:
+        """One page of the sessions the caller may see (``{"sessions": [...], "totalRecords": n}``).
+
+        Filters, in snake_case: ``mine``, ``user_id``, ``user_ids``, ``circuit``, ``circuit_code``,
+        ``telemetry_data_available``, ``video_available``, ``weather_temperature_min``, ``weather_temperature_max``,
+        ``weather_conditions``, ``from_`` and ``to`` (datetimes).
+        """
+        return self._client.request("POST", "api/session/search", json_body=_body(dict(filters, active_page_index=page, page_size=page_size)))
+
+    def iterate(self, *, page_size: int = 20, **filters: Any) -> Iterator[JSON]:
+        """Every session of a search, page after page."""
+        page, seen = 1, 0
+        while True:
+            result = self.search(page=page, page_size=page_size, **filters)
+            sessions = result.get("sessions") or []
+            yield from sessions
+            seen += len(sessions)
+            if not sessions or seen >= (result.get("totalRecords") or 0):
+                return
+            page += 1
+
+    def get(self, session_id: str) -> JSON:
+        """A session with its laps, sectors and telemetry channels."""
+        return self._client.request("GET", f"api/session/{_segment(session_id)}")
+
+    def update(self, session_id: str, **changes: Any) -> JSON:
+        """Changes ``label``, ``description``, ``notes``, ``sharing`` (Public, Laptimes, Restricted, Private),
+        ``vehicle_id`` or ``setup`` of one of the caller's sessions; the others are left as they are."""
+        return self._client.request("PATCH", f"api/session/{_segment(session_id)}", json_body=_body(changes))
+
+    def delete(self, session_id: str) -> None:
+        self._client.request("DELETE", f"api/session/{_segment(session_id)}")
+
+    def telemetry(self, session_id: str, lap: Optional[int] = None, *, generator: Optional[str] = None) -> JSON:
+        """The laps and the samples of every channel, for the whole session or one lap (from 1)."""
+        path = f"api/session/alldata/{_segment(session_id)}" + (f"/{int(lap)}" if lap is not None else "")
+        return self._client.request("GET", path, query={"generator": generator})
+
+    def channel(self, session_id: str, lap: int, channel: str) -> List[JSON]:
+        """The samples of one channel during one lap: ``[{"s": seconds, "d": value}, ...]``."""
+        return self._client.request("GET", f"api/session/data/{_segment(session_id)}/{int(lap)}/{_segment(channel)}") or []
+
+    def export(self, session_id: str, format: str, output: PathLike, *, generator: Optional[str] = None) -> str:
+        """Writes the session in another format (csv, gpx, kml, srt, original...) to ``output``; returns its path."""
+        return self._client._download(f"api/session/export/{_segment(session_id)}/{_segment(format)}", output, {"generator": generator})
+
+    def download(self, session_id: str, output: PathLike) -> str:
+        """Writes the session in the LapViz format (.lvz), every sample and timing source, to ``output``."""
+        return self._client._download(f"api/session/{_segment(session_id)}/file", output)
+
+    def vehicles(self) -> List[JSON]:
+        """The vehicles of the caller, the primary one first: the values of ``vehicle_id``."""
+        return self._client.request("GET", "api/session/vehicles") or []
+
+    def changes(self, cursor: Optional[str] = None, page_size: int = 200) -> JSON:
+        """One page of the change feed since ``cursor`` (None: the whole library). Keep its ``cursor`` for the next
+        call; call again while ``hasMore``."""
+        return self._client.request("GET", "api/session/changes", query={"cursor": cursor, "pageSize": page_size})
+
+    def sync(self, cursor: Optional[str] = None, page_size: int = 200) -> Tuple[List[JSON], List[JSON], Optional[str]]:
+        """Every change since ``cursor``: (sessions created or changed, sessions deleted, the cursor to keep)."""
+        changed: List[JSON] = []
+        deleted: List[JSON] = []
+        while True:
+            page = self.changes(cursor, page_size)
+            changed.extend(page.get("sessions") or [])
+            deleted.extend(page.get("deleted") or [])
+            cursor = page.get("cursor") or cursor
+            if not page.get("hasMore"):
+                return changed, deleted, cursor
+
+
+class Imports(_Resource):
+    """Data logger and lap timer files, read in the background: upload, then wait for the sessions."""
+
+    PENDING_STATES = ("Enqueued", "Processing")
+
+    def upload(
+        self,
+        file: Union[PathLike, bytes, BinaryIO],
+        *,
+        filename: Optional[str] = None,
+        driver: Optional[str] = None,
+        source_device: Optional[str] = None,
+    ) -> JSON:
+        """Sends a file (a path, bytes or a binary file object); returns ``{"jobId": ...}``. ``driver``: "auto"
+        (recognized from the previous imports) or the id of a driver the caller coaches; None for the caller."""
+        if isinstance(file, (bytes, bytearray)):
+            content, name = bytes(file), filename or "upload.bin"
+        elif hasattr(file, "read"):
+            content, name = file.read(), filename or os.path.basename(getattr(file, "name", "upload.bin"))
+        else:
+            with open(file, "rb") as handle:
+                content = handle.read()
+            name = filename or os.path.basename(os.fspath(file))
+
+        boundary = "lapviz-" + uuid.uuid4().hex
+        safe_name = name.replace("\\", "_").replace('"', "_").replace("\r", "").replace("\n", "")
+        data = (
+            f"--{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"{safe_name}\"\r\n"
+            "Content-Type: application/octet-stream\r\n\r\n"
+        ).encode("utf-8") + content + f"\r\n--{boundary}--\r\n".encode("ascii")
+        headers = {"Content-Type": f"multipart/form-data; boundary={boundary}"}
+        if driver:
+            headers["lv-driver"] = driver
+        if source_device:
+            headers["lv-source-device"] = source_device
+        return self._client.request("POST", "api/session/import", data=data, headers=headers)
+
+    def status(self, job_id: str) -> JSON:
+        """State of an import: ``Enqueued`` or ``Processing``, then ``Success`` (``shareIds``) or ``Failed``."""
+        return self._client.request("GET", f"api/session/import/{_segment(job_id)}")
+
+    def wait(self, job_id: str, *, timeout: float = 300, interval: float = 2) -> JSON:
+        """Polls the import until it ends; raises TimeoutError after ``timeout`` seconds."""
+        deadline = time.monotonic() + timeout
+        while True:
+            status = self.status(job_id)
+            if status.get("state") not in self.PENDING_STATES:
+                return status
+            if time.monotonic() + interval > deadline:
+                raise TimeoutError(f"Import {job_id} still {status.get('state')} after {timeout} s")
+            time.sleep(interval)
+
+    def drivers(self) -> List[JSON]:
+        """The drivers the caller may import sessions for: themselves first, then the drivers they coach."""
+        return self._client.request("GET", "api/session/import/drivers") or []
+
+
+class Teams(_Resource):
+    """Teams of the caller; the other operations are in the reference (``client.request``)."""
+
+    def list(self) -> List[JSON]:
+        return self._client.request("GET", "api/teams") or []
+
+    def get(self, team_key: str) -> JSON:
+        return self._client.request("GET", f"api/teams/{_segment(team_key)}")
+
+    def create(self, name: str, description: Optional[str] = None, roles: Optional[List[str]] = None) -> JSON:
+        return self._client.request("POST", "api/teams", json_body=_body({"name": name, "description": description, "roles": roles}))
+
+    def invitations(self) -> List[JSON]:
+        """The teams whose admins invited the caller, waiting for an answer."""
+        return self._client.request("GET", "api/teams/invitations") or []
+
+
+class Webhooks(_Resource):
+    """Addresses that receive the events of the account, signed (see ``lapviz.verify_signature``)."""
+
+    EVENTS = ("session.created", "session.updated", "session.deleted", "import.failed")
+
+    def list(self) -> List[JSON]:
+        return self._client.request("GET", "api/webhooks") or []
+
+    def create(self, url: str, events: Optional[List[str]] = None, description: Optional[str] = None) -> JSON:
+        """Creates a webhook (every event by default); the answer carries its ``secret``, shown only once."""
+        return self._client.request("POST", "api/webhooks", json_body=_body({"url": url, "events": list(events or self.EVENTS), "description": description}))
+
+    def get(self, webhook_id: str) -> JSON:
+        return self._client.request("GET", f"api/webhooks/{_segment(webhook_id)}")
+
+    def update(self, webhook_id: str, **changes: Any) -> JSON:
+        """Changes ``url``, ``description``, ``events``, or ``enabled`` (False pauses, True resumes)."""
+        return self._client.request("PATCH", f"api/webhooks/{_segment(webhook_id)}", json_body=_body(changes))
+
+    def delete(self, webhook_id: str) -> None:
+        self._client.request("DELETE", f"api/webhooks/{_segment(webhook_id)}")
+
+    def deliveries(self, webhook_id: str, take: Optional[int] = None) -> List[JSON]:
+        return self._client.request("GET", f"api/webhooks/{_segment(webhook_id)}/deliveries", query={"take": take}) or []
+
+    def ping(self, webhook_id: str) -> JSON:
+        return self._client.request("POST", f"api/webhooks/{_segment(webhook_id)}/ping")
+
+    def rotate_secret(self, webhook_id: str) -> JSON:
+        """A new signing secret (in ``secret``); the previous one stops signing at once."""
+        return self._client.request("POST", f"api/webhooks/{_segment(webhook_id)}/secret")
+
+    def redeliver(self, delivery_id: str) -> JSON:
+        return self._client.request("POST", f"api/webhooks/deliveries/{_segment(delivery_id)}/redeliver")
+
+
+class Circuits(_Resource):
+    """The circuits of LapViz. Public: no key needed."""
+
+    def search(self, text: Optional[str] = None, *, page: int = 1, page_size: int = 20) -> JSON:
+        """``{"circuits": [...], "totalRecords": n}``, by name, code, venue or location."""
+        return self._client.request("GET", "api/circuit/search", query={"text": text, "p": page, "s": page_size})
+
+    def nearby(self, lat: float, lon: float, radius: Optional[float] = None) -> JSON:
+        """The 10 circuits closest to a position, nearest first."""
+        return self._client.request("GET", "api/circuit/nearby", query={"lat": lat, "lon": lon, "radius": radius})

lapviz/errors.py

@@ -0,0 +1,63 @@
+"""Errors of the LapViz API: RFC 9457 problem details turned into exceptions."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+
+class LapVizError(Exception):
+    """An answer of the API that is not a success (4xx, 5xx), or a server that could not be reached (status 0)."""
+
+    def __init__(self, status: int, title: str, detail: Optional[str] = None, problem: Optional[Dict[str, Any]] = None):
+        self.status = status
+        self.title = title
+        self.detail = detail
+        self.problem = problem or {}
+        super().__init__(f"{status} {title}" + (f": {detail}" if detail else ""))
+
+
+class AuthenticationError(LapVizError):
+    """401: missing, invalid, expired or revoked key or token."""
+
+
+class PermissionDeniedError(LapVizError):
+    """403: forbidden, e.g. a read-only API key on an operation that changes something."""
+
+
+class NotFoundError(LapVizError):
+    """404: unknown, or a session the caller may not see (the API does not tell them apart)."""
+
+
+class RateLimitError(LapVizError):
+    """429: too many requests; retry_after is the number of seconds to wait."""
+
+    def __init__(self, status: int, title: str, detail: Optional[str] = None, problem: Optional[Dict[str, Any]] = None, retry_after: Optional[float] = None):
+        super().__init__(status, title, detail, problem)
+        self.retry_after = retry_after
+
+
+_BY_STATUS = {401: AuthenticationError, 403: PermissionDeniedError, 404: NotFoundError}
+
+
+def error_for(status: int, body: Any, retry_after: Optional[float] = None) -> LapVizError:
+    """The exception of an answer: its problem details when the body has them, else the HTTP status alone."""
+    problem = body if isinstance(body, dict) else {}
+    title = str(problem.get("title") or _REASONS.get(status, "Error"))
+    detail = problem.get("detail") or (body.strip()[:500] if isinstance(body, str) and body.strip() else None)
+    if status == 429:
+        return RateLimitError(status, title, detail, problem, retry_after)
+    return _BY_STATUS.get(status, LapVizError)(status, title, detail, problem)
+
+
+_REASONS = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    409: "Conflict",
+    410: "Gone",
+    413: "Payload Too Large",
+    429: "Too Many Requests",
+    500: "Internal Server Error",
+    503: "Service Unavailable",
+}

lapviz/webhooks.py

@@ -0,0 +1,53 @@
+"""Checks the requests LapViz posts to a webhook (https://lapviz.com/developers/docs#webhooks).
+
+The ``LapViz-Signature`` header (``t=...,v1=...``) is the hexadecimal HMAC-SHA256 of ``{t}.{body}`` with the secret
+of the webhook.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import time
+from typing import Optional, Union
+
+SIGNATURE_HEADER = "LapViz-Signature"
+EVENT_HEADER = "LapViz-Event"
+DEFAULT_TOLERANCE = 300  # Seconds: older signatures are refused (replays)
+
+
+def compute_signature(secret: str, timestamp: int, body: Union[str, bytes]) -> str:
+    """The hexadecimal HMAC-SHA256 of ``{timestamp}.{body}``."""
+    payload = body if isinstance(body, bytes) else body.encode("utf-8")
+    return hmac.new(secret.encode("utf-8"), str(timestamp).encode("ascii") + b"." + payload, hashlib.sha256).hexdigest()
+
+
+def verify_signature(
+    secret: str,
+    signature_header: Optional[str],
+    body: Union[str, bytes],
+    tolerance: float = DEFAULT_TOLERANCE,
+    now: Optional[float] = None,
+) -> bool:
+    """True when ``signature_header`` signs ``body`` (the raw request body, before any JSON parsing) with ``secret``
+    and is not older than ``tolerance`` seconds."""
+    if not secret or not signature_header or body is None:
+        return False
+
+    timestamp = None
+    signature = None
+    for part in signature_header.split(","):
+        name, separator, value = part.partition("=")
+        if not separator:
+            continue
+        name, value = name.strip(), value.strip()
+        if name == "t" and value.isdigit():
+            timestamp = int(value)
+        elif name == "v1":
+            signature = value
+
+    if timestamp is None or signature is None:
+        return False
+    if abs((time.time() if now is None else now) - timestamp) > tolerance:
+        return False
+    return hmac.compare_digest(compute_signature(secret, timestamp, body), signature)

lapviz-1.0.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.5
+Name: lapviz
+Version: 1.0.0
+Summary: Official Python client of the LapViz API: lap timing sessions, telemetry, imports, webhooks and circuits.
+Project-URL: Homepage, https://lapviz.com/developers
+Project-URL: Documentation, https://lapviz.com/developers/docs
+Project-URL: Reference, https://lapviz.com/swagger
+Project-URL: Changelog, https://lapviz.com/developers/docs#changelog
+Author-email: Mengal SRL <support@lapviz.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,karting,lap timing,lapviz,motorsport,telemetry
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# LapViz for Python
+
+The official Python client of the [LapViz API](https://lapviz.com/developers): lap timing sessions, telemetry, file
+imports, the change feed of a library, webhooks and circuits. Standard library only, Python 3.10+, MIT licensed.
+
+```bash
+pip install lapviz
+```
+
+## Quickstart
+
+Create a personal API key in [Account › API keys](https://lapviz.com/Identity/Account/Manage/ApiKeys) and put it in
+the `LAPVIZ_API_KEY` environment variable (never in your code).
+
+```python
+from lapviz import LapViz
+
+lapviz = LapViz()  # reads LAPVIZ_API_KEY; or LapViz(api_key="lvz_...")
+print(lapviz.me()["username"])
+
+for session in lapviz.sessions.iterate(mine=True):
+    print(session["shareId"], session["start"], session["best"])
+```
+
+Responses are the JSON of the API, as dicts with the camelCase names of the
+[reference](https://lapviz.com/swagger): new fields appear without a new version of this package.
+
+## Telemetry
+
+```python
+session = lapviz.sessions.get("7e2b5e")
+speed = lapviz.sessions.channel("7e2b5e", lap=3, channel="GPS Speed")  # [{"s": seconds, "d": value}, ...]
+everything = lapviz.sessions.telemetry("7e2b5e", lap=3)                 # laps and every channel
+lapviz.sessions.export("7e2b5e", "csv", "session.csv")
+lapviz.sessions.download("7e2b5e", "session.lvz")                       # LapViz format, every sample
+```
+
+Reading public sessions (like the demo sessions of the guides) works without a key; exports need one.
+
+## Import a file
+
+```python
+job = lapviz.imports.upload("run.xrk")            # AiM, Alfano, Unipro, RaceBox, RaceChrono, MyChron...
+status = lapviz.imports.wait(job["jobId"])        # polls until Success or Failed
+print(status["state"], status.get("shareIds"))
+```
+
+## Keep a copy of a library
+
+```python
+changed, deleted, cursor = lapviz.sessions.sync(saved_cursor)  # None the first time: the whole library
+save(cursor)
+```
+
+## Webhooks
+
+```python
+hook = lapviz.webhooks.create("https://example.com/lapviz", events=["session.created"])
+secret = hook["secret"]  # shown once: store it
+```
+
+In your receiver, check the signature on the raw body before parsing it:
+
+```python
+from lapviz import verify_signature, SIGNATURE_HEADER
+
+if not verify_signature(secret, request.headers.get(SIGNATURE_HEADER), request.get_data()):
+    abort(400)
+```
+
+## Errors and limits
+
+Errors raise `LapVizError` (with `status`, `title`, `detail` and the `problem` details), or one of its subclasses
+`AuthenticationError` (401), `PermissionDeniedError` (403), `NotFoundError` (404) and `RateLimitError` (429, with
+`retry_after`). The client waits and retries twice on 429 and 503; `lapviz.rate_limit` holds the RateLimit headers of
+the last response.
+
+## Anything else
+
+Every operation of the reference is one call away:
+
+```python
+lapviz.request("PUT", f"api/teams/{key}/share", json_body={"share": True})
+```
+
+OAuth applications pass `LapViz(access_token="lvzat_...")` instead of a key. Guides:
+[lapviz.com/developers/docs](https://lapviz.com/developers/docs).

lapviz-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+lapviz/__init__.py,sha256=xYlR_yALtIsUQ8XwbnOYLdMB_dfyxPiJyR7lvRGP3Us,626
+lapviz/client.py,sha256=6WijOr-Kpw_idHkv-_Us7meA_58hsvcCUTwZT8nFKFw,18282
+lapviz/errors.py,sha256=qoBlRnhTq7uDjNP__EOk8OPU-BsKASkkTLY-_zBvKHw,2355
+lapviz/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lapviz/webhooks.py,sha256=3ZkNQGyhnCRa5qlAP7BfdOrHev5Yz-B4OvNobFxjkBY,1899
+lapviz-1.0.0.dist-info/METADATA,sha256=ND_J70fqob4fo3ZxY0qhon3P0lzHUkljNXmbPlUDH6A,3903
+lapviz-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lapviz-1.0.0.dist-info/licenses/LICENSE,sha256=SQx-xggAndwhldn8Ai7rEj1HsquPE2gWdbVitzLJvJ8,1067
+lapviz-1.0.0.dist-info/RECORD,,

lapviz-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

lapviz-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mengal SRL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.