renpho-py 1.0.0__py3-none-any.whl

renpho/__init__.py

@@ -0,0 +1,24 @@
+"""renpho - Unofficial Python client for the Renpho Health API.
+
+Pull body composition measurements from Renpho smart scales.
+
+Quick start::
+
+    from renpho import RenphoClient
+
+    client = RenphoClient("user@example.com", "password")
+    client.login()
+    measurements = client.get_all_measurements()
+"""
+
+from .client import RenphoAPIError, RenphoClient
+from .export import format_measurement, format_timestamp, save_csv, save_json
+
+__all__ = [
+    "RenphoClient",
+    "RenphoAPIError",
+    "format_measurement",
+    "format_timestamp",
+    "save_csv",
+    "save_json",
+]

renpho/cli.py

@@ -0,0 +1,111 @@
+"""Command-line interface for pulling Renpho scale data."""
+
+import os
+import sys
+from pathlib import Path
+
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ImportError:
+    pass
+
+from .client import RenphoClient
+from .export import format_measurement, save_csv, save_json
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Entry point for the ``renpho`` CLI command."""
+    email = os.getenv("RENPHO_EMAIL", "")
+    password = os.getenv("RENPHO_PASSWORD", "")
+    debug = os.getenv("RENPHO_DEBUG", "").lower() in ("1", "true", "yes")
+    output_dir = Path(os.getenv("RENPHO_OUTPUT_DIR", "renpho_data"))
+
+    if not email or not password:
+        print("Missing credentials!\n")
+        print("Create a .env file with:")
+        print("  RENPHO_EMAIL=your@email.com")
+        print("  RENPHO_PASSWORD=your_plain_text_password")
+        print("  RENPHO_DEBUG=1  # optional")
+        sys.exit(1)
+
+    client = RenphoClient(email, password, debug=debug)
+
+    # Step 1: Login
+    print(f"Logging in as {email}...")
+    client.login()
+    print(f"Logged in! User ID: {client.user_id}")
+
+    # Step 2: Device info
+    print("Getting device info...")
+    device_info = client.get_device_info()
+
+    if not device_info:
+        print("Could not get device info")
+        sys.exit(1)
+
+    save_json(device_info, output_dir / "device_info.json")
+
+    scales = device_info.get("scale", [])
+    if not scales:
+        print("No scales found in device info")
+        print(f"  Device info keys: {list(device_info.keys())}")
+        sys.exit(1)
+
+    print(f"\nFound {len(scales)} scale table(s):")
+    for i, scale in enumerate(scales):
+        table = scale.get("tableName", "unknown")
+        count = scale.get("count", 0)
+        uids = scale.get("userIds", [])
+        print(f"  [{i}] table={table}, records={count}, users={uids}")
+
+    # Step 3: Fetch measurements
+    all_measurements: list[dict] = []
+    for scale in scales:
+        table_name = scale.get("tableName")
+        count = scale.get("count", 0)
+        user_ids = scale.get("userIds", [])
+
+        if not table_name or count == 0:
+            continue
+
+        uid = client.user_id
+        if user_ids and uid not in user_ids:
+            uid = user_ids[0]
+
+        print(f"Fetching measurements (table: {table_name}, total: {count})...")
+        measurements = client.get_measurements(table_name, uid, count)
+        all_measurements.extend(measurements)
+
+    if not all_measurements:
+        print("\nNo measurements found.")
+        print("  Try setting RENPHO_DEBUG=1 to see API responses.")
+        return
+
+    # Sort newest first
+    all_measurements.sort(
+        key=lambda m: m.get("timeStamp", 0) or 0,
+        reverse=True,
+    )
+
+    print(f"\nTotal: {len(all_measurements)} measurement(s)")
+
+    # Display most recent 5
+    for i, m in enumerate(all_measurements[:5]):
+        print(f"\n{'=' * 55}")
+        print(f"  Measurement #{i + 1}")
+        print(f"{'=' * 55}")
+        print(format_measurement(m))
+
+    if len(all_measurements) > 5:
+        print(f"\n  ... and {len(all_measurements) - 5} more")
+
+    # Save data
+    save_json(all_measurements, output_dir / "measurements.json")
+    save_csv(all_measurements, output_dir / "measurements.csv")
+
+    if client.user_info:
+        save_json(client.user_info, output_dir / "user_profile.json")
+
+    print(f"\nDone! Data saved to '{output_dir}/' folder.")

renpho/client.py

@@ -0,0 +1,398 @@
+"""Renpho API client for fetching scale measurements."""
+
+import json
+import sys
+
+import requests
+
+from .constants import (
+    API_BASE_URL,
+    APP_VERSION,
+    BODY_WEIGHT_SCALES,
+    ENDPOINTS,
+    MEASUREMENT_TABLE_NAMES,
+    PLATFORM,
+    SUCCESS_CODES,
+)
+from .crypto import (
+    decrypt_response,
+    encrypt_empty_bytes,
+    encrypt_empty_object,
+    encrypt_request,
+)
+
+
+class RenphoAPIError(Exception):
+    """Raised when the Renpho API returns an error response."""
+
+    def __init__(self, context: str, code, msg: str):
+        self.context = context
+        self.code = code
+        self.msg = msg
+        super().__init__(f"{context} failed: code={code}, msg={msg}")
+
+
+def _check_response(result: dict, context: str = "API call") -> None:
+    """Raise :class:`RenphoAPIError` if the response indicates failure."""
+    code = result.get("code")
+    msg = result.get("msg", "")
+    if msg.lower() == "success" or code in SUCCESS_CODES:
+        return
+    raise RenphoAPIError(context, code, msg)
+
+
+class RenphoClient:
+    """Client for the Renpho cloud API.
+
+    Example::
+
+        client = RenphoClient("user@example.com", "password")
+        client.login()
+        measurements = client.get_all_measurements()
+        for m in measurements:
+            print(m["weight"], m.get("bodyfat"))
+    """
+
+    def __init__(self, email: str, password: str, *, debug: bool = False):
+        self.email = email
+        self.password = password
+        self.debug = debug
+        self.token: str | None = None
+        self.user_id: int | str | None = None
+        self.user_info: dict | None = None
+        self._session = requests.Session()
+
+    # ----- internal helpers -----
+
+    def _post(self, endpoint: str, body: dict, *, auth: bool = True) -> dict:
+        """Make an encrypted POST request to the Renpho API."""
+        url = f"{API_BASE_URL}/{endpoint}"
+        headers: dict[str, str] = {}
+        if auth and self.token:
+            headers["token"] = self.token
+            headers["userId"] = str(self.user_id)
+            headers["appVersion"] = APP_VERSION
+            headers["platform"] = PLATFORM
+
+        if self.debug:
+            print(f"  POST {url}")
+            if auth and self.token:
+                print(f"  Headers: token={self.token[:20]}..., userId={self.user_id}")
+
+        resp = self._session.post(url, json=body, headers=headers)
+
+        if self.debug:
+            print(f"  Status: {resp.status_code}")
+            print(f"  Response: {resp.text[:300]}")
+
+        resp.raise_for_status()
+        return resp.json()
+
+    # ----- public API -----
+
+    def login(self) -> dict:
+        """Authenticate and store the session token.
+
+        Returns the full decrypted login response (includes user profile).
+
+        Raises:
+            RenphoAPIError: If the API rejects the credentials.
+            requests.HTTPError: On transport-level failures.
+        """
+        login_payload = {
+            "questionnaire": {},
+            "login": {
+                "password": self.password,
+                "areaCode": "US",
+                "appRevision": APP_VERSION,
+                "cellphoneType": "PythonScript",
+                "systemType": "11",
+                "email": self.email,
+                "platform": PLATFORM,
+            },
+            "bindingList": {
+                "deviceTypes": BODY_WEIGHT_SCALES,
+            },
+        }
+
+        encrypted_body = encrypt_request(login_payload)
+        result = self._post(ENDPOINTS["login"], encrypted_body, auth=False)
+        _check_response(result, "Login")
+
+        user_data = decrypt_response(result["data"])
+
+        if self.debug:
+            print(f"  Decrypted login: {json.dumps(user_data, indent=2)[:500]}")
+
+        login_info = user_data.get("login", {})
+        self.token = login_info.get("token")
+        self.user_id = login_info.get("id")
+        self.user_info = login_info
+
+        if not self.token:
+            raise RenphoAPIError("Login", None, "No token in login response")
+
+        return user_data
+
+    def get_device_info(self) -> dict:
+        """Get device info including scale table names and record counts.
+
+        Returns:
+            Decrypted device info dict (contains ``scale`` list among others).
+
+        Raises:
+            RenphoAPIError: On API-level failure.
+        """
+        for attempt, body_fn in enumerate([encrypt_empty_bytes, encrypt_empty_object]):
+            encrypted_body = body_fn()
+            try:
+                result = self._post(ENDPOINTS["device_info"], encrypted_body)
+                break
+            except requests.exceptions.HTTPError as e:
+                if attempt == 0:
+                    if self.debug:
+                        print(
+                            f"  Attempt 1 failed ({e}), retrying with empty object..."
+                        )
+                    continue
+                raise
+
+        _check_response(result, "GetDeviceInfo")
+        data = decrypt_response(result["data"])
+
+        if self.debug:
+            print(f"  Device info: {json.dumps(data, indent=2)[:500]}")
+
+        return data
+
+    def get_measurements(
+        self, table_name: str, user_id, total_count: int, *, page_size: int = 50
+    ) -> list[dict]:
+        """Fetch measurements from a specific scale table with pagination.
+
+        Args:
+            table_name: Dynamic table name from :meth:`get_device_info`.
+            user_id: The user ID to query for.
+            total_count: Total records available (from device info).
+            page_size: Records per page (default 50).
+
+        Returns:
+            List of measurement dicts.
+        """
+        all_measurements: list[dict] = []
+        page = 1
+
+        while len(all_measurements) < total_count:
+            request_data = {
+                "pageNum": page,
+                "pageSize": page_size,
+                "userIds": [str(user_id)],
+                "tableName": table_name,
+            }
+
+            if self.debug:
+                print(f"  Page {page} (got {len(all_measurements)} so far)...")
+
+            encrypted_body = encrypt_request(request_data)
+            result = self._post(ENDPOINTS["measurements"], encrypted_body)
+            _check_response(result, f"Measurements page {page}")
+
+            if not result.get("data"):
+                break
+
+            page_data = decrypt_response(result["data"])
+
+            if self.debug:
+                if isinstance(page_data, list):
+                    print(f"  Got {len(page_data)} records")
+                else:
+                    print(f"  Response type: {type(page_data)}")
+
+            records = self._extract_records(page_data)
+            if records is None:
+                break
+
+            all_measurements.extend(records)
+            page += 1
+
+        return all_measurements
+
+    def get_body_composition_measurements(
+        self, table_name: str, user_id, *, page_size: int = 50
+    ) -> list[dict]:
+        """Fetch body composition measurements using the newer API endpoint.
+
+        Body composition scales (those with impedance sensors) store data under
+        ``queryBodyCompositionMeasureData`` rather than ``queryAllMeasureDataList``.
+        The server-side count in device info is often reported as 0 for these
+        scales even when data exists, so this method paginates until the server
+        returns an empty page rather than relying on a total count.
+
+        Args:
+            table_name: Dynamic table name from :meth:`get_device_info`.
+            user_id: The user ID to query for.
+            page_size: Records per page (default 50).
+
+        Returns:
+            List of measurement dicts.
+        """
+        all_measurements: list[dict] = []
+        page = 1
+
+        while True:
+            request_data = {
+                "pageNum": page,
+                "pageSize": page_size,
+                "userIds": [str(user_id)],
+                "tableName": table_name,
+            }
+
+            if self.debug:
+                print(f"  Page {page} (got {len(all_measurements)} so far)...")
+
+            encrypted_body = encrypt_request(request_data)
+            result = self._post(
+                ENDPOINTS["body_composition_measurements"], encrypted_body
+            )
+            _check_response(result, f"BodyCompositionMeasurements page {page}")
+
+            if not result.get("data"):
+                break
+
+            page_data = decrypt_response(result["data"])
+
+            if self.debug:
+                if isinstance(page_data, list):
+                    print(f"  Got {len(page_data)} records")
+                else:
+                    print(f"  Response type: {type(page_data)}")
+
+            records = self._extract_records(page_data)
+            if not records:
+                break
+
+            all_measurements.extend(records)
+            if len(records) < page_size:
+                break
+            page += 1
+
+        return all_measurements
+
+    def discover_user_tables(self, user_id) -> list[str]:
+        """Probe all measurement tables for a given user_id and return the ones with data.
+
+        Body composition scales shard measurements across 16 tables
+        (``measurements_info_0`` through ``measurements_info_F``). The server
+        only reports the table for the logged-in user via ``device/count``,
+        so for any other linked account this method probes each suffix.
+
+        Args:
+            user_id: The user ID to probe for.
+
+        Returns:
+            List of table names that contain at least one record for ``user_id``.
+        """
+        found: list[str] = []
+        for table in MEASUREMENT_TABLE_NAMES:
+            encrypted_body = encrypt_request({
+                "pageNum": 1,
+                "pageSize": 1,
+                "userIds": [str(user_id)],
+                "tableName": table,
+            })
+            result = self._post(ENDPOINTS["body_composition_measurements"], encrypted_body)
+            if not result.get("data"):
+                continue
+            page_data = decrypt_response(result["data"])
+            records = self._extract_records(page_data)
+            if records:
+                found.append(table)
+        return found
+
+    def get_all_measurements(self, extra_user_ids: list | None = None) -> list[dict]:
+        """High-level helper: fetch device info then pull all measurements.
+
+        Tries the body composition endpoint first (used by impedance scales).
+        Falls back to the basic measurements endpoint for weight-only scales.
+        The server-side count in device info is unreliable for body composition
+        scales (often reports 0), so this method always attempts a fetch.
+
+        Calls :meth:`login` first if no token is set.
+
+        Args:
+            extra_user_ids: Additional user IDs to fetch measurements for. The
+                Renpho API allows a logged-in user to read measurements belonging
+                to other linked accounts (e.g. a separate account from before a
+                Google SSO migration). Each id is probed against all known
+                measurement tables. Pass these when you have multiple Renpho
+                accounts associated with the same physical scale.
+
+        Returns:
+            List of measurement dicts sorted by timestamp (newest first),
+            deduped by record ``id``.
+        """
+        if not self.token:
+            self.login()
+
+        device_info = self.get_device_info()
+        scales = device_info.get("scale", [])
+
+        all_measurements: list[dict] = []
+        for scale in scales:
+            table_name = scale.get("tableName")
+            count = scale.get("count", 0)
+            user_ids = scale.get("userIds", [])
+
+            if not table_name:
+                continue
+
+            uid = self.user_id
+            if user_ids and uid not in user_ids:
+                uid = user_ids[0]
+
+            # Try body composition endpoint first; it handles both newer
+            # impedance scales and cases where count is incorrectly zero.
+            measurements = self.get_body_composition_measurements(table_name, uid)
+            if not measurements and count > 0:
+                measurements = self.get_measurements(table_name, uid, count)
+
+            all_measurements.extend(measurements)
+
+        for extra_uid in extra_user_ids or []:
+            for table in self.discover_user_tables(extra_uid):
+                all_measurements.extend(
+                    self.get_body_composition_measurements(table, extra_uid)
+                )
+
+        # Dedupe by record id (each measurement is a unique server-side row).
+        seen_ids: set = set()
+        unique: list[dict] = []
+        for m in all_measurements:
+            rid = m.get("id")
+            if rid is not None and rid in seen_ids:
+                continue
+            if rid is not None:
+                seen_ids.add(rid)
+            unique.append(m)
+
+        unique.sort(
+            key=lambda m: m.get("timeStamp", 0) or 0,
+            reverse=True,
+        )
+        return unique
+
+    @staticmethod
+    def _extract_records(page_data) -> list[dict] | None:
+        """Extract measurement records from a page response."""
+        if isinstance(page_data, list):
+            return page_data if page_data else None
+
+        if isinstance(page_data, dict):
+            for key in ("list", "data", "records", "measurements"):
+                if key in page_data and isinstance(page_data[key], list):
+                    return page_data[key] if page_data[key] else None
+
+            if "weight" in page_data:
+                return [page_data]
+
+        return None

renpho/constants.py

@@ -0,0 +1,52 @@
+"""Constants and configuration for the Renpho API."""
+
+# API connection
+API_BASE_URL = "https://cloud.renpho.com"
+ENCRYPTION_KEY = "ed*wijdi$h6fe3ew"  # 16-byte AES-128 key
+APP_VERSION = "6.6.0"
+PLATFORM = "android"
+
+# API endpoints (from RenphoApiEndpoints.cs)
+ENDPOINTS = {
+    "login": "renpho-aggregation/user/login",
+    "token_time": "RenphoHealth/app/sync/getTokenTime",
+    "device_info": "renpho-aggregation/device/count",
+    "family": "RenphoHealth/centerUser/queryFamilyMemberList",
+    "measurements": "RenphoHealth/scale/queryAllMeasureDataList",
+    "body_composition_measurements": "RenphoHealth/scale/queryBodyCompositionMeasureData",
+    "body_composition_scale_count": "RenphoHealth/scale/bodyCompositionScaleCount",
+}
+
+# Body composition scales shard measurements across 16 tables. Server-side
+# discovery only reports the table for the logged-in user, so the only way
+# to find data belonging to other linked accounts is to probe each suffix.
+MEASUREMENT_TABLE_NAMES = [f"measurements_info_{i:X}" for i in range(16)]
+
+# Body weight scale device types
+BODY_WEIGHT_SCALES = [
+    "01", "02", "03", "04", "05", "06", "07", "08", "09", "0A",
+    "0B", "0C", "0D", "0E", "0F", "10", "11", "12", "13", "14",
+]
+
+# Measurement display metadata: (api_key, label, unit)
+METRICS = [
+    ("weight", "Weight", "kg"),
+    ("bmi", "BMI", ""),
+    ("bodyfat", "Body Fat", "%"),
+    ("water", "Body Water", "%"),
+    ("muscle", "Muscle Mass", "%"),
+    ("bone", "Bone Mass", "%"),
+    ("bmr", "BMR", "kcal/day"),
+    ("visfat", "Visceral Fat", "level"),
+    ("subfat", "Subcutaneous Fat", "%"),
+    ("protein", "Protein", "%"),
+    ("bodyage", "Body Age", "years"),
+    ("sinew", "Lean Body Mass", "kg"),
+    ("fatFreeWeight", "Fat Free Weight", "kg"),
+    ("heartRate", "Heart Rate", "bpm"),
+    ("cardiacIndex", "Cardiac Index", ""),
+    ("bodyShape", "Body Shape", ""),
+]
+
+# Success codes returned by the API
+SUCCESS_CODES = {0, "0", 101, "101", 200, "200", 20000, "20000"}

renpho/crypto.py

@@ -0,0 +1,54 @@
+"""AES-128-ECB encryption utilities for the Renpho API.
+
+The Renpho cloud API encrypts all request/response payloads using
+AES-128-ECB with PKCS7 padding, base64-encoded for transport.
+"""
+
+import base64
+import json
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+
+from .constants import ENCRYPTION_KEY
+
+
+def aes_encrypt(plaintext: str, key: str = ENCRYPTION_KEY) -> str:
+    """Encrypt a string with AES-128-ECB + PKCS7 padding, return base64."""
+    cipher = AES.new(key.encode("utf-8"), AES.MODE_ECB)
+    padded = pad(plaintext.encode("utf-8"), AES.block_size)
+    encrypted = cipher.encrypt(padded)
+    return base64.b64encode(encrypted).decode("utf-8")
+
+
+def aes_decrypt(encrypted_b64: str, key: str = ENCRYPTION_KEY) -> str:
+    """Decrypt a base64 AES-128-ECB + PKCS7 string."""
+    cipher = AES.new(key.encode("utf-8"), AES.MODE_ECB)
+    encrypted = base64.b64decode(encrypted_b64)
+    decrypted = unpad(cipher.decrypt(encrypted), AES.block_size)
+    return decrypted.decode("utf-8")
+
+
+def encrypt_request(obj: dict, key: str = ENCRYPTION_KEY) -> dict:
+    """Encrypt a request payload into ``{"encryptData": "..."}`` format."""
+    serialized = json.dumps(obj, separators=(",", ":"))
+    return {"encryptData": aes_encrypt(serialized, key)}
+
+
+def encrypt_empty_object(key: str = ENCRYPTION_KEY) -> dict:
+    """Encrypt an empty JSON object ``{}``."""
+    return encrypt_request({}, key)
+
+
+def encrypt_empty_bytes(key: str = ENCRYPTION_KEY) -> dict:
+    """Encrypt an empty byte array (used by some endpoints)."""
+    cipher = AES.new(key.encode("utf-8"), AES.MODE_ECB)
+    padded = pad(b"", AES.block_size)
+    encrypted = cipher.encrypt(padded)
+    return {"encryptData": base64.b64encode(encrypted).decode("utf-8")}
+
+
+def decrypt_response(encrypted_data: str, key: str = ENCRYPTION_KEY):
+    """Decrypt the ``data`` field from an API response and parse as JSON."""
+    decrypted = aes_decrypt(encrypted_data, key)
+    return json.loads(decrypted)

renpho/export.py

@@ -0,0 +1,95 @@
+"""Helpers for formatting, displaying, and exporting Renpho measurements."""
+
+import datetime
+import json
+from pathlib import Path
+
+from .constants import METRICS
+
+
+def format_timestamp(ts) -> str:
+    """Convert a Renpho timestamp (seconds or milliseconds) to a readable string."""
+    if ts is None:
+        return "unknown"
+    ts = int(ts)
+    if ts > 1e12:
+        ts = ts // 1000
+    return datetime.datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M:%S")
+
+
+def format_measurement(m: dict) -> str:
+    """Return a human-readable string for a single measurement."""
+    ts = m.get("timeStamp") or m.get("time_stamp")
+    local = m.get("localCreatedAt", "")
+    scale = m.get("scaleName", "")
+
+    lines = [f"  Date: {format_timestamp(ts)}"]
+    if local:
+        lines.append(f"  Local time: {local}")
+    if scale:
+        lines.append(f"  Scale: {scale}")
+
+    for key, label, unit in METRICS:
+        value = m.get(key)
+        if value is not None and value != 0 and value != 0.0:
+            unit_str = f" {unit}" if unit else ""
+            lines.append(f"  {label:<22} {value}{unit_str}")
+
+    return "\n".join(lines)
+
+
+def save_json(data, filepath: str | Path) -> Path:
+    """Write *data* as pretty-printed JSON.
+
+    Parent directories are created automatically.
+
+    Returns:
+        The resolved :class:`~pathlib.Path` that was written.
+    """
+    filepath = Path(filepath)
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    with open(filepath, "w") as f:
+        json.dump(data, f, indent=2, default=str)
+    return filepath
+
+
+def save_csv(measurements: list[dict], filepath: str | Path) -> Path | None:
+    """Write measurements to a CSV file.
+
+    Columns are ordered with the most useful metrics first, followed by any
+    remaining keys in alphabetical order.
+
+    Returns:
+        The resolved :class:`~pathlib.Path` that was written, or ``None`` if
+        *measurements* is empty.
+    """
+    if not measurements:
+        return None
+
+    filepath = Path(filepath)
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+
+    priority = [
+        "timeStamp", "localCreatedAt",
+        *(key for key, _, _ in METRICS),
+        "scaleName", "height", "gender",
+    ]
+
+    all_keys: set[str] = set()
+    for m in measurements:
+        all_keys.update(m.keys())
+
+    columns = [k for k in priority if k in all_keys]
+    columns += sorted(k for k in all_keys if k not in columns)
+
+    with open(filepath, "w") as f:
+        f.write(",".join(columns) + "\n")
+        for m in measurements:
+            row = []
+            for k in columns:
+                val = m.get(k, "")
+                val_str = str(val).replace(",", ";") if val is not None else ""
+                row.append(val_str)
+            f.write(",".join(row) + "\n")
+
+    return filepath

renpho_py-1.0.0.dist-info/METADATA

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: renpho-py
+Version: 1.0.0
+Summary: Unofficial Renpho Health API client for Python — pull body composition data from Renpho smart scales.
+Author: ChocoTonic
+Maintainer: ChocoTonic
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ChocoTonic/renpho-py
+Project-URL: Repository, https://github.com/ChocoTonic/renpho-py
+Project-URL: Issues, https://github.com/ChocoTonic/renpho-py/issues
+Project-URL: Changelog, https://github.com/ChocoTonic/renpho-py/blob/main/CHANGELOG.md
+Keywords: renpho,renpho-api,health,body-composition,smart-scale,api-client,python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: requests>=2.28
+Requires-Dist: pycryptodome>=3.15
+Provides-Extra: dotenv
+Requires-Dist: python-dotenv>=1.0; extra == "dotenv"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# renpho-py — Renpho Health API client for Python
+
+[![PyPI](https://img.shields.io/pypi/v/renpho-py)](https://pypi.org/project/renpho-py/)
+[![CI](https://github.com/ChocoTonic/renpho-py/actions/workflows/ci.yml/badge.svg)](https://github.com/ChocoTonic/renpho-py/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/pypi/pyversions/renpho-py)](https://pypi.org/project/renpho-py/)
+
+Unofficial **Renpho Health API** client for **Python**. Pull body composition
+measurements from Renpho smart scales programmatically.
+
+> **Unofficial.** Not affiliated with, endorsed by, or supported by Renpho. Use
+> at your own risk and in line with Renpho's terms of service.
+
+`renpho-py` is an independently maintained continuation of the abandoned
+[`renpho-api`](https://github.com/danvaneijck/renpho-api) (MIT). The import name
+is unchanged, so migrating is a one-line swap — `pip install renpho-py` and your
+existing `from renpho import ...` code keeps working. The underlying API was
+reverse-engineered; protocol details are based on
+[RenphoGarminSync-CLI](https://github.com/forkerer/RenphoGarminSync-CLI).
+
+## Installation
+
+```bash
+pip install renpho-py
+```
+
+For `.env` file support (recommended for CLI usage):
+
+```bash
+pip install "renpho-py[dotenv]"
+```
+
+> Migrating from `renpho-api`? `pip uninstall renpho-api && pip install renpho-py`.
+> No code changes — you still `from renpho import RenphoClient`.
+
+## CLI Usage
+
+1. Create a `.env` file (or export the variables):
+
+```
+RENPHO_EMAIL=your@email.com
+RENPHO_PASSWORD=your_plain_text_password
+```
+
+2. Run the CLI:
+
+```bash
+renpho
+```
+
+This will log in, discover your scales, fetch all measurements, print the 5 most recent, and save everything to `renpho_data/` as JSON and CSV.
+
+### Environment variables
+
+| Variable | Required | Description |
+| --- | --- | --- |
+| `RENPHO_EMAIL` | Yes | Your Renpho account email |
+| `RENPHO_PASSWORD` | Yes | Your Renpho account password |
+| `RENPHO_DEBUG` | No | Set to `1` to print API request/response details |
+| `RENPHO_OUTPUT_DIR` | No | Output directory (default: `renpho_data`) |
+
+## Library Usage
+
+```python
+from renpho import RenphoClient
+
+client = RenphoClient("user@example.com", "password")
+client.login()
+
+# Fetch all measurements in one call
+measurements = client.get_all_measurements()
+
+for m in measurements:
+    print(m["weight"], m.get("bodyfat"), m.get("muscle"))
+```
+
+### Step-by-step control
+
+```python
+from renpho import RenphoClient, save_json, save_csv
+
+client = RenphoClient("user@example.com", "password")
+client.login()
+
+# Get device/scale info
+device_info = client.get_device_info()
+scales = device_info["scale"]
+
+# Fetch from a specific scale table
+# Use get_body_composition_measurements() for scales with impedance sensors
+# (body fat, muscle, etc.) — the server-side count is unreliable for these.
+# Fall back to get_measurements() for weight-only scales.
+table = scales[0]
+measurements = client.get_body_composition_measurements(
+    table_name=table["tableName"],
+    user_id=client.user_id,
+)
+if not measurements:
+    measurements = client.get_measurements(
+        table_name=table["tableName"],
+        user_id=client.user_id,
+        total_count=table["count"],
+    )
+
+# Export
+save_json(measurements, "my_data.json")
+save_csv(measurements, "my_data.csv")
+```
+
+### Multiple Renpho accounts on one email
+
+Some users end up with **two Renpho accounts under the same email** — for
+example after the Google SSO migration created an orphan account, or after
+re-registering. Each account has its own user ID and its own measurement
+table, so the default `get_all_measurements()` will only return data from
+the account you log in to.
+
+If you know the other account's user ID, pass it in:
+
+```python
+measurements = client.get_all_measurements(
+    extra_user_ids=["5975813831868809088"],
+)
+```
+
+The library will probe every measurement table for that user ID, fetch
+matching records, and dedupe by record `id` so you get a single combined
+timeline.
+
+**How to find your other user ID:**
+
+Unfortunately there is no first-party API endpoint that lists "all
+accounts associated with this email" — Renpho treats accounts as
+independent even when emails collide. Options:
+
+1. **Renpho support** — email them and ask for your user ID(s) on file
+2. **Inspect the iOS / Android app** — sign in to the other account in
+   the official app and look in Settings / Account / Help → Feedback
+   pages (the user ID is sometimes visible there)
+3. **Capture network traffic** — proxy the official app through
+   mitmproxy, sign in, and look at any request body containing
+   `userId` (decrypt with the published AES-128 key — see the
+   reverse-engineering write-up linked at the top of this README)
+
+Once you have the ID, save it alongside your credentials and you won't
+need to discover it again.
+
+### Error handling
+
+```python
+from renpho import RenphoClient, RenphoAPIError
+
+client = RenphoClient("user@example.com", "wrong_password")
+try:
+    client.login()
+except RenphoAPIError as e:
+    print(f"API error: {e}")
+```
+
+## Available Metrics
+
+Each measurement dict can contain these fields (availability depends on your scale model):
+
+| Key | Description | Unit |
+| --- | --- | --- |
+| `weight` | Weight | kg |
+| `bmi` | BMI | |
+| `bodyfat` | Body Fat | % |
+| `water` | Body Water | % |
+| `muscle` | Muscle Mass | % |
+| `bone` | Bone Mass | % |
+| `bmr` | Basal Metabolic Rate | kcal/day |
+| `visfat` | Visceral Fat | level |
+| `subfat` | Subcutaneous Fat | % |
+| `protein` | Protein | % |
+| `bodyage` | Body Age | years |
+| `sinew` | Lean Body Mass | kg |
+| `fatFreeWeight` | Fat Free Weight | kg |
+| `heartRate` | Heart Rate | bpm |
+| `cardiacIndex` | Cardiac Index | |
+| `bodyShape` | Body Shape | |
+
+## Project Structure
+
+```
+renpho-py/
+├── pyproject.toml        # Package config & dependencies (dist name: renpho-py)
+├── README.md
+├── CHANGELOG.md
+├── LICENSE               # MIT (original + current attribution)
+├── NOTICE
+├── renpho/               # import name — unchanged for drop-in migration
+│   ├── __init__.py       # Public API exports
+│   ├── py.typed          # PEP 561 typing marker
+│   ├── client.py         # RenphoClient class
+│   ├── cli.py            # CLI entry point
+│   ├── constants.py      # API endpoints, device types, metrics
+│   ├── crypto.py         # AES encryption/decryption
+│   └── export.py         # JSON/CSV export helpers
+├── tests/                # Unit tests
+└── .github/workflows/    # CI + PyPI release automation (trusted publishing)
+```

renpho_py-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+renpho/__init__.py,sha256=DCTXlSyeSIEHjwy6yTCUS0-h8KXggLUZbnYeqTYn_RQ,577
+renpho/cli.py,sha256=qzKcR-5elrAzqXvie_4Ci6NZfz7lmHqPTjAbslXN8fo,3402
+renpho/client.py,sha256=BzaRHW6t_dyoX0RWfZQxPlAm8YekVQZwvzG-bv4k0kQ,13575
+renpho/constants.py,sha256=3KEupjDJFYu9RsCokV712AovM3uIMY6MZ5f53eaBEhY,1981
+renpho/crypto.py,sha256=bUxDKBvApp2Yecv-uLW_llqAI8tMY727AmNl7PPh1_4,1984
+renpho/export.py,sha256=v-yTgQfuQBVkgvoBm2J0iiPieh8L9HRpz3XBHlu4ZX4,2784
+renpho/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+renpho_py-1.0.0.dist-info/licenses/LICENSE,sha256=hzGmcViLVRuPU3Ee7OISMZ4kRrX6z2hZbZzf18IHaE8,1161
+renpho_py-1.0.0.dist-info/licenses/NOTICE,sha256=doXreO8gsc-WJKAPGw7NEfatr-T48nelRuFSOyyl67w,714
+renpho_py-1.0.0.dist-info/METADATA,sha256=tzIp5M31-M1_y6Jd8WUkO3XsARElLCa0Qer-qfW3Mu4,7969
+renpho_py-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+renpho_py-1.0.0.dist-info/entry_points.txt,sha256=WwzgR408BL15AZ7hsgqvYQovrIpD6y1u2RBnS6VkaLo,43
+renpho_py-1.0.0.dist-info/top_level.txt,sha256=4Fx37UUXPT1K_IYsJnxDaGbvbssufPBZZCpYG-Zw4Bs,7
+renpho_py-1.0.0.dist-info/RECORD,,

renpho_py-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

renpho_py-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+renpho = renpho.cli:main

renpho_py-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 danvaneijck (original renpho-api)
+Copyright (c) 2026 ChocoTonic (renpho-py and subsequent modifications)
+
+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.

renpho_py-1.0.0.dist-info/licenses/NOTICE

@@ -0,0 +1,16 @@
+renpho-py
+========
+
+This project began as a copy of the MIT-licensed `renpho-api`
+(https://github.com/danvaneijck/renpho-api) by danvaneijck, and is now
+independently maintained. The original license and copyright are preserved in
+LICENSE.
+
+The underlying Renpho cloud API was reverse-engineered; the approach and
+protocol details are based on RenphoGarminSync-CLI
+(https://github.com/forkerer/RenphoGarminSync-CLI).
+
+renpho-py is UNOFFICIAL and is not affiliated with, endorsed by, or supported by
+Renpho or any of its affiliates. "Renpho" is a trademark of its respective
+owner and is used here only to describe the API this client targets. Use at
+your own risk and in accordance with Renpho's terms of service.

renpho_py-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+renpho