py-livewire 0.1.0__tar.gz → 0.2.0__tar.gz

{py_livewire-0.1.0 → py_livewire-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-livewire
-Version: 0.1.0
+Version: 0.2.0
 Summary: Async Python client for the LiveWire electric motorcycle cloud API
 Author-email: Igor Novgorodov <igor@novg.net>
 License-Expression: Apache-2.0

{py_livewire-0.1.0 → py_livewire-0.2.0}/py_livewire/__init__.py

@@ -19,7 +19,7 @@ from .models import (
 )
 from .utils import uuid_from_android_id
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = [
     "ApiError",

{py_livewire-0.1.0 → py_livewire-0.2.0}/py_livewire/auth.py

@@ -6,7 +6,7 @@ from typing import Any
 import aiohttp
 
 from . import const
-from .exceptions import AuthenticationError
+from .exceptions import ApiError, AuthenticationError
 
 
 def jwt_subject(token: str) -> str | None:
@@ -25,7 +25,10 @@ class Authenticator:
     """Logs in to Gigya and exchanges the account UID for a LiveWire session token.
 
     The token carries no usable expiry and there is no refresh flow, so it is used until
-    the backend rejects it, which triggers a full login again.
+    the backend rejects it. The account UID is cached after the first login, so renewing
+    a rejected token only re-requests a session token and the Gigya password login runs
+    just once. This avoids hammering Gigya when the token expires: the password is only
+    needed to obtain the UID, not to mint the token.
     """
 
     def __init__(
@@ -46,6 +49,7 @@ class Authenticator:
         self._api_url = api_url
 
         self._token: str | None = None
+        self._uid: str | None = None
         self._lock = asyncio.Lock()
         self.terms_accepted: bool | None = None
 
@@ -67,8 +71,11 @@ class Authenticator:
             return self._token
 
     async def _login(self, session: aiohttp.ClientSession) -> str:
-        uid = await self._gigya_uid(session)
-        return await self._session_token(session, uid)
+        # The UID is stable, so the Gigya password login only runs to obtain it the
+        # first time; renewing an expired token re-requests a session token with it.
+        if self._uid is None:
+            self._uid = await self._gigya_uid(session)
+        return await self._session_token(session, self._uid)
 
     async def _gigya_uid(self, session: aiohttp.ClientSession) -> str:
         # Gigya expects a form and reports errors in a body with HTTP 200
@@ -84,13 +91,16 @@ class Authenticator:
         ) as resp:
             res: dict[str, Any] = await resp.json(content_type=None)
 
-        if res.get("errorCode", 0) != 0:
-            raise AuthenticationError(
-                f"Gigya login failed: {res.get('errorMessage')} "
-                f"({res.get('errorCode')})"
-            )
+        error_code = res.get("errorCode", 0)
+        if error_code != 0:
+            message = f"Gigya login failed: {res.get('errorMessage')} ({error_code})"
+            if error_code in const.GIGYA_CREDENTIAL_ERRORS:
+                raise AuthenticationError(message)
+            # A transient Gigya problem (rate limit, captcha, server error): retryable,
+            # re-entering the credentials would not help.
+            raise ApiError(message, code=str(error_code))
         if not res.get("UID"):
-            raise AuthenticationError("Gigya login returned no UID")
+            raise ApiError("Gigya login returned no UID")
 
         return str(res["UID"])
 
@@ -112,7 +122,9 @@ class Authenticator:
             res = {}
         if not res.get("jwt"):
             detail = (res.get("error") or {}).get("description") or f"HTTP {status}"
-            raise AuthenticationError(f"session request failed: {detail}")
+            # The session endpoint does not use the password, so a failure here is a
+            # backend or transient problem, not a credential one: retryable, not reauth.
+            raise ApiError(f"session request failed: {detail}", status=status)
 
         self.terms_accepted = res.get("termsAccepted")
         return str(res["jwt"])

{py_livewire-0.1.0 → py_livewire-0.2.0}/py_livewire/const.py

@@ -19,6 +19,18 @@ LANGUAGE = "en-US"
 
 KM_PER_MILE = 1.609344
 
+# Gigya accounts.login errorCodes that mean the credentials are the problem, so
+# that re-entering them could help: a wrong loginID or password, or an account the
+# user still has to finish setting up. Any other Gigya error (rate limit, captcha,
+# server error) is transient and should be retried, not reported as a login failure.
+GIGYA_CREDENTIAL_ERRORS = frozenset(
+    {
+        403042,  # invalid loginID or password
+        206001,  # account pending registration
+        206002,  # account pending verification
+    }
+)
+
 # Values of error.code in the response envelope
 CODE_OK = "0"
 CODE_PARTIAL = "-300"  # the app still shows the charging data that comes with it

{py_livewire-0.1.0 → py_livewire-0.2.0}/py_livewire.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-livewire
-Version: 0.1.0
+Version: 0.2.0
 Summary: Async Python client for the LiveWire electric motorcycle cloud API
 Author-email: Igor Novgorodov <igor@novg.net>
 License-Expression: Apache-2.0

{py_livewire-0.1.0 → py_livewire-0.2.0}/tests/test_client.py

@@ -39,6 +39,9 @@ class Backend:
         self.handlers: dict[tuple[str, str], Handler] = {}
         self.next_token = make_jwt("user-1", 1)
         self.valid_token = self.next_token
+        self.gigya_logins = 0
+        self.gigya_error: dict | None = None
+        self.session_error: dict | None = None
 
     def route(self, method: str, path: str, data=None, status: int = 200) -> None:
         async def handler(request: web.Request) -> web.StreamResponse:
@@ -56,8 +59,11 @@ class Backend:
         return app
 
     async def gigya(self, request: web.Request) -> web.Response:
+        self.gigya_logins += 1
         form = await request.post()
         assert form["apiKey"] == "4_6aX8cf8RFVt6F3JQQZaF3A"
+        if self.gigya_error is not None:
+            return web.json_response(self.gigya_error)
         if form["password"] != "secret":
             return web.json_response(
                 {"errorCode": 403042, "errorMessage": "Invalid LoginID"}
@@ -66,6 +72,8 @@ class Backend:
 
     async def session(self, request: web.Request) -> web.Response:
         self.sessions.append(await request.json())
+        if self.session_error is not None:
+            return web.json_response(self.session_error, status=500)
         self.valid_token = self.next_token
         return web.json_response({"jwt": self.valid_token, "termsAccepted": True})
 
@@ -181,14 +189,44 @@ def test_relogin_on_401():
 
     async def test(client: Client):
         await client.login()
-        # the backend expires the token, the next login yields a new one
+        # the backend expires the token, the next request yields a new one
         backend.valid_token = None
         backend.next_token = make_jwt("user-1", 2)
 
         assert len(await client.get_bikes()) == 1
 
     run(test, backend)
+    # The expired token is renewed from a new session token, reusing the cached UID:
+    # a second session request, but no second Gigya password login.
     assert len(backend.sessions) == 2
+    assert backend.gigya_logins == 1
+
+
+def test_transient_gigya_error_is_retryable():
+    backend = Backend()
+    backend.gigya_error = {"errorCode": 500001, "errorMessage": "General Server Error"}
+
+    async def test(client: Client):
+        with pytest.raises(ApiError) as err:
+            await client.login()
+        assert not isinstance(err.value, AuthenticationError)
+        assert err.value.code == "500001"
+
+    run(test, backend)
+
+
+def test_session_failure_is_retryable():
+    # The session endpoint does not use the password, so its failure must not look like
+    # an authentication failure (which would trigger a pointless reauth).
+    backend = Backend()
+    backend.session_error = {"error": {"description": "backend down"}}
+
+    async def test(client: Client):
+        with pytest.raises(ApiError) as err:
+            await client.login()
+        assert not isinstance(err.value, AuthenticationError)
+
+    run(test, backend)
 
 
 def test_pair():