aioamazondevices 0.6.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

aioamazondevices/__init__.py

@@ -1,6 +1,6 @@
 """aioamazondevices library."""
 
-__version__ = "0.6.0"
+__version__ = "0.7.1"
 
 
 from .api import AmazonDevice, AmazonEchoApi

aioamazondevices/api.py

@@ -2,29 +2,37 @@
 
 import base64
 import hashlib
+import mimetypes
 import secrets
 import uuid
 from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+from http import HTTPStatus
 from pathlib import Path
 from typing import Any
-from urllib.parse import urlencode
+from urllib.parse import parse_qs, urlencode
 
 import orjson
 from bs4 import BeautifulSoup, Tag
-from httpx import AsyncClient, Response
+from httpx import URL, AsyncClient, Response
 
 from .const import (
     _LOGGER,
     AMAZON_APP_BUNDLE_ID,
     AMAZON_APP_ID,
+    AMAZON_APP_NAME,
     AMAZON_APP_VERSION,
-    AMAZON_SERIAL_NUMBER,
-    AMAZON_SOFTWARE_VERSION,
+    AMAZON_CLIENT_OS,
+    AMAZON_DEVICE_SOFTWARE_VERSION,
+    AMAZON_DEVICE_TYPE,
+    DEFAULT_ASSOC_HANDLE,
     DEFAULT_HEADERS,
     DOMAIN_BY_COUNTRY,
+    HTML_EXTENSION,
+    JSON_EXTENSION,
     URI_QUERIES,
 )
-from .exceptions import CannotAuthenticate
+from .exceptions import CannotAuthenticate, CannotRegisterDevice
 
 
 @dataclass
@@ -57,9 +65,10 @@ class AmazonEchoApi:
         locale = DOMAIN_BY_COUNTRY.get(country_code)
         domain = locale["domain"] if locale else country_code
 
-        assoc_handle = "amzn_dp_project_dee_ios"
-        if not locale:
-            assoc_handle += f"_{country_code}"
+        if locale and (assoc := locale.get("openid.assoc_handle")):
+            assoc_handle = assoc
+        else:
+            assoc_handle = f"{DEFAULT_ASSOC_HANDLE}_{country_code}"
         self._assoc_handle = assoc_handle
 
         self._login_email = login_email
@@ -69,6 +78,7 @@ class AmazonEchoApi:
         self._cookies = self._build_init_cookies()
         self._headers = DEFAULT_HEADERS
         self._save_html = save_html
+        self._serial = uuid.uuid4().hex.upper()
 
         self.session: AsyncClient
 
@@ -80,7 +90,7 @@ class AmazonEchoApi:
         map_md_dict = {
             "device_user_dictionary": [],
             "device_registration_data": {
-                "software_version": AMAZON_SOFTWARE_VERSION,
+                "software_version": AMAZON_DEVICE_SOFTWARE_VERSION,
             },
             "app_identifier": {
                 "app_version": AMAZON_APP_VERSION,
@@ -102,9 +112,9 @@ class AmazonEchoApi:
         m = hashlib.sha256(verifier)
         return base64.urlsafe_b64encode(m.digest()).rstrip(b"=")
 
-    def _build_client_id(self, serial: str) -> str:
+    def _build_client_id(self) -> str:
         """Build client ID."""
-        client_id = serial.encode() + AMAZON_SERIAL_NUMBER
+        client_id = self._serial.encode() + b"#" + AMAZON_DEVICE_TYPE.encode("utf-8")
         return client_id.hex()
 
     def _build_oauth_url(
@@ -161,6 +171,11 @@ class AmazonEchoApi:
                 return method, url
         raise TypeError("Unable to extract form data from response.")
 
+    def _extract_code_from_url(self, url: URL) -> str:
+        """Extract the access token from url query after login."""
+        parsed_url = parse_qs(url.query.decode())
+        return parsed_url["openid.oa2.authorization_code"][0]
+
     def _client_session(self) -> None:
         """Create httpx ClientSession."""
         if not hasattr(self, "session") or self.session.is_closed:
@@ -185,31 +200,22 @@ class AmazonEchoApi:
             url,
             data=input_data,
         )
-        content_type = resp.headers.get("Content-Type", "")
+        content_type: str = resp.headers.get("Content-Type", "")
         _LOGGER.debug("Response content type: %s", content_type)
 
-        if "text/html" in content_type:
-            await self._save_to_file(
-                resp.text,
-                url,
-            )
-        elif content_type == "application/json":
-            await self._save_to_file(
-                orjson.dumps(
-                    orjson.loads(resp.text),
-                    option=orjson.OPT_INDENT_2,
-                ).decode("utf-8"),
-                url,
-                extension="json",
-            )
+        await self._save_to_file(
+            resp.text,
+            url,
+            mimetypes.guess_extension(content_type.split(";")[0]) or ".raw",
+        )
 
         return BeautifulSoup(resp.content, "html.parser"), resp
 
     async def _save_to_file(
         self,
-        html_code: str,
+        raw_data: str | dict,
         url: str,
-        extension: str = "html",
+        extension: str = HTML_EXTENSION,
         output_path: str = "out",
     ) -> None:
         """Save response data to disk."""
@@ -219,19 +225,138 @@ class AmazonEchoApi:
         output_dir = Path(output_path)
         output_dir.mkdir(parents=True, exist_ok=True)
 
-        url_split = url.split("/")
-        filename = f"{url_split[3]}-{url_split[4].split('?')[0]}.{extension}"
-        with Path.open(output_dir / filename, "w+") as file:
-            file.write(html_code)
+        if url.startswith("http"):
+            url_split = url.split("/")
+            base_filename = f"{url_split[3]}-{url_split[4].split('?')[0]}"
+        else:
+            base_filename = url
+        fullpath = Path(output_dir, base_filename + extension)
+
+        if type(raw_data) is dict:
+            data = orjson.dumps(raw_data, option=orjson.OPT_INDENT_2).decode("utf-8")
+        elif extension == HTML_EXTENSION:
+            data = raw_data
+        else:
+            data = orjson.dumps(
+                orjson.loads(raw_data),
+                option=orjson.OPT_INDENT_2,
+            ).decode("utf-8")
+
+        i = 2
+        while fullpath.exists():
+            filename = f"{base_filename}_{i!s}{extension}"
+            fullpath = Path(output_dir, filename)
+            i += 1
+
+        _LOGGER.warning("Saving data to %s", fullpath)
+
+        with Path.open(fullpath, "w+") as file:
+            file.write(data)
             file.write("\n")
 
-    async def login(self, otp_code: str) -> bool:
+    async def _register_device(
+        self,
+        data: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Register a dummy Alexa device."""
+        authorization_code: str = data["authorization_code"]
+        code_verifier: bytes = data["code_verifier"]
+
+        body = {
+            "requested_extensions": ["device_info", "customer_info"],
+            "cookies": {"website_cookies": [], "domain": f".amazon.{self._domain}"},
+            "registration_data": {
+                "domain": "Device",
+                "app_version": AMAZON_APP_VERSION,
+                "device_type": AMAZON_DEVICE_TYPE,
+                "device_name": (
+                    f"%FIRST_NAME%\u0027s%DUPE_STRATEGY_1ST%{AMAZON_APP_NAME}"
+                ),
+                "os_version": AMAZON_CLIENT_OS,
+                "device_serial": self._serial,
+                "device_model": "iPhone",
+                "app_name": AMAZON_APP_NAME,
+                "software_version": AMAZON_DEVICE_SOFTWARE_VERSION,
+            },
+            "auth_data": {
+                "client_id": self._build_client_id(),
+                "authorization_code": authorization_code,
+                "code_verifier": code_verifier.decode(),
+                "code_algorithm": "SHA-256",
+                "client_domain": "DeviceLegacy",
+            },
+            "user_context_map": {"frc": self._cookies["frc"]},
+            "requested_token_type": [
+                "bearer",
+                "mac_dms",
+                "website_cookies",
+                "store_authentication_cookie",
+            ],
+        }
+
+        headers = {"Content-Type": "application/json"}
+
+        register_url = f"https://api.amazon.{self._domain}/auth/register"
+        resp = await self.session.post(
+            register_url,
+            json=body,
+            headers=headers,
+        )
+        resp_json = resp.json()
+
+        if resp.status_code != HTTPStatus.OK:
+            _LOGGER.error(
+                "Cannot register device for %s: %s",
+                self._login_email,
+                resp_json["response"]["error"]["message"],
+            )
+            raise CannotRegisterDevice(resp_json)
+
+        await self._save_to_file(
+            resp.text,
+            url=register_url,
+            extension=JSON_EXTENSION,
+        )
+        success_response = resp_json["response"]["success"]
+
+        tokens = success_response["tokens"]
+        adp_token = tokens["mac_dms"]["adp_token"]
+        device_private_key = tokens["mac_dms"]["device_private_key"]
+        store_authentication_cookie = tokens["store_authentication_cookie"]
+        access_token = tokens["bearer"]["access_token"]
+        refresh_token = tokens["bearer"]["refresh_token"]
+        expires_s = int(tokens["bearer"]["expires_in"])
+        expires = (datetime.now(UTC) + timedelta(seconds=expires_s)).timestamp()
+
+        extensions = success_response["extensions"]
+        device_info = extensions["device_info"]
+        customer_info = extensions["customer_info"]
+
+        website_cookies = {}
+        for cookie in tokens["website_cookies"]:
+            website_cookies[cookie["Name"]] = cookie["Value"].replace(r'"', r"")
+
+        login_data = {
+            "adp_token": adp_token,
+            "device_private_key": device_private_key,
+            "access_token": access_token,
+            "refresh_token": refresh_token,
+            "expires": expires,
+            "website_cookies": website_cookies,
+            "store_authentication_cookie": store_authentication_cookie,
+            "device_info": device_info,
+            "customer_info": customer_info,
+        }
+        await self._save_to_file(login_data, "login_data", JSON_EXTENSION)
+        return login_data
+
+    async def login(self, otp_code: str) -> dict[str, Any]:
         """Login to Amazon."""
         _LOGGER.debug("Logging-in for %s [otp code %s]", self._login_email, otp_code)
         self._client_session()
 
         code_verifier = self._create_code_verifier()
-        client_id = self._build_client_id(uuid.uuid4().hex.upper())
+        client_id = self._build_client_id()
 
         _LOGGER.debug("Build oauth URL")
         login_url = self._build_oauth_url(code_verifier, client_id)
@@ -279,7 +404,16 @@ class AmazonEchoApi:
         if authcode_url is None:
             raise CannotAuthenticate
 
-        return True
+        device_login_data = {
+            "authorization_code": self._extract_code_from_url(authcode_url),
+            "code_verifier": code_verifier,
+            "domain": self._domain,
+        }
+
+        register_device = await self._register_device(device_login_data)
+
+        _LOGGER.info("Register device: %s", register_device)
+        return register_device
 
     async def close(self) -> None:
         """Close httpx session."""

aioamazondevices/const.py

@@ -4,10 +4,12 @@ import logging
 
 _LOGGER = logging.getLogger(__package__)
 
+DEFAULT_ASSOC_HANDLE = "amzn_dp_project_dee_ios"
+
 DOMAIN_BY_COUNTRY = {
     "us": {
         "domain": "com",
-        "openid.assoc_handle": "amzn_dp_project_dee_ios",
+        "openid.assoc_handle": DEFAULT_ASSOC_HANDLE,
     },
     "uk": {
         "domain": "co.uk",
@@ -17,6 +19,7 @@ DOMAIN_BY_COUNTRY = {
     },
     "jp": {
         "domain": "co.jp",
+        "openid.assoc_handle": "jpflex",
     },
     "br": {
         "domain": "com.br",
@@ -40,8 +43,15 @@ URI_QUERIES = {
     "bluetooth": "/api/bluetooth",
 }
 
-AMAZON_APP_BUNDLE_ID = "com.audible.iphone"
+# Amazon APP info
+AMAZON_APP_BUNDLE_ID = "com.amazon.echo"
 AMAZON_APP_ID = "MAPiOSLib/6.0/ToHideRetailLink"
-AMAZON_APP_VERSION = "3.56.2"
-AMAZON_SOFTWARE_VERSION = "35602678"
-AMAZON_SERIAL_NUMBER = b"#A2CZJZGLK2JJVM"
+AMAZON_APP_NAME = "AioAmazonDevices"
+AMAZON_APP_VERSION = "2.2.556530.0"
+AMAZON_DEVICE_SOFTWARE_VERSION = "35602678"
+AMAZON_DEVICE_TYPE = "A2IVLV5VM2W81"
+AMAZON_CLIENT_OS = "16.6"
+
+# File extensions
+HTML_EXTENSION = ".html"
+JSON_EXTENSION = ".json"

aioamazondevices/exceptions.py

@@ -17,3 +17,7 @@ class CannotAuthenticate(AmazonError):
 
 class CannotRetrieveData(AmazonError):
     """Exception raised when data retrieval fails."""
+
+
+class CannotRegisterDevice(AmazonError):
+    """Exception raised when device registration fails."""

{aioamazondevices-0.6.0.dist-info → aioamazondevices-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aioamazondevices
-Version: 0.6.0
+Version: 0.7.1
 Summary: Python library to control Amazon devices
 Home-page: https://github.com/chemelli74/aioamazondevices
 License: Apache Software License 2.0
@@ -15,8 +15,10 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Requires-Dist: beautifulsoup4
+Requires-Dist: colorlog
 Requires-Dist: httpx
 Requires-Dist: orjson
 Project-URL: Bug Tracker, https://github.com/chemelli74/aioamazondevices/issues

aioamazondevices-0.7.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+aioamazondevices/__init__.py,sha256=IxGu-Lv8_pSEPCQnjhVi-_VdJGmh9WI0NOELkRSSVjQ,276
+aioamazondevices/api.py,sha256=3Gshun5XSEbD47aDs-hyQkZ_zVYuQ3OMwXIaZA13lmo,15902
+aioamazondevices/const.py,sha256=CQFuM-4gFrzveQcBMsH6noI8PN69J4ogV-P46uYhcTQ,1330
+aioamazondevices/exceptions.py,sha256=yQ9nL4UwBdHNXvdRj8TRemed6PXBmExP8lbHaAp04vY,546
+aioamazondevices/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aioamazondevices-0.7.1.dist-info/LICENSE,sha256=sS48k5sp9bFV-NSHDfAJuTZZ_-AP9ZDqUzQ9sffGlsg,11346
+aioamazondevices-0.7.1.dist-info/METADATA,sha256=Eq-0torKLJNk79WSTqq2I4pnPqAM-VsQ3u8ibrVytUo,4755
+aioamazondevices-0.7.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+aioamazondevices-0.7.1.dist-info/RECORD,,

{aioamazondevices-0.6.0.dist-info → aioamazondevices-0.7.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

aioamazondevices-0.6.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-aioamazondevices/__init__.py,sha256=yo5hkSgxhpMQLUQO67XfINgQNxrncsWR32abuZzsals,276
-aioamazondevices/api.py,sha256=_KQtNmw7mOEMOxWmLl0MAQj_MLnTngL_zJzgxQUqfwg,10830
-aioamazondevices/const.py,sha256=bZaeO8AeJbDc5hdlbJ3cMwM9teTgYhExSR1oEpRFMLk,1089
-aioamazondevices/exceptions.py,sha256=tERMur_gry9TmU3UyzndJO_CLViISn4b8ClrRbryFy8,444
-aioamazondevices/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aioamazondevices-0.6.0.dist-info/LICENSE,sha256=sS48k5sp9bFV-NSHDfAJuTZZ_-AP9ZDqUzQ9sffGlsg,11346
-aioamazondevices-0.6.0.dist-info/METADATA,sha256=kE5iT7Eid9foSh4dKTHaLVGw_0TezvDqCGDWZtH3Qes,4680
-aioamazondevices-0.6.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-aioamazondevices-0.6.0.dist-info/RECORD,,