cronopy 0.1.0__py3-none-any.whl

cronopy/__init__.py

@@ -0,0 +1,29 @@
+"""Unofficial cli for cronometer."""
+
+from cronopy.client import (
+    CronometerClient,
+    CronometerError,
+    LoginError,
+    NotAuthenticatedError,
+    Source,
+)
+from cronopy.session import (
+    Session,
+    default_session_path,
+    delete_session,
+    load_session,
+    save_session,
+)
+
+__all__ = [
+    "CronometerClient",
+    "CronometerError",
+    "LoginError",
+    "NotAuthenticatedError",
+    "Session",
+    "Source",
+    "default_session_path",
+    "delete_session",
+    "load_session",
+    "save_session",
+]

cronopy/cli.py

@@ -0,0 +1,174 @@
+"""Unofficial command line interface for Cronometer."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.table import Table
+
+from cronopy.client import CronometerClient, CronometerError, NotAuthenticatedError, Source
+from cronopy.session import default_session_path, delete_session, load_session, save_session
+
+app = typer.Typer(
+    help="Unofficial cli for cronometer.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+err_console = Console(stderr=True)
+
+
+@app.callback()
+def _root(
+    debug: Annotated[
+        bool,
+        typer.Option(
+            "--debug",
+            "-d",
+            help="Log every HTTP request/response and internal step.",
+            envvar="CRONOPY_DEBUG",
+        ),
+    ] = False,
+) -> None:
+    if not debug:
+        return
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(name)s: %(message)s",
+        datefmt="[%X]",
+        handlers=[
+            RichHandler(console=err_console, rich_tracebacks=True, show_path=False, markup=False)
+        ],
+        force=True,
+    )
+    for name in ("httpx", "cronopy"):
+        logging.getLogger(name).setLevel(logging.DEBUG)
+    logging.getLogger("httpcore").setLevel(logging.INFO)  # raw socket trace is too noisy
+    err_console.print("[dim]debug logging enabled[/dim]")
+
+
+def _fail(message: str, code: int = 1) -> None:
+    err_console.print(f"[red]Error:[/red] {message}")
+    raise typer.Exit(code)
+
+
+def _client_from_disk() -> CronometerClient:
+    session = load_session()
+    if session is None:
+        _fail(f"Not logged in (no session at {default_session_path()}). Run `crono login`.")
+    return CronometerClient(session)
+
+
+@app.command()
+def login(
+    email: Annotated[
+        str,
+        typer.Option("--email", "-e", prompt=True, help="Cronometer account email."),
+    ],
+    password: Annotated[
+        str,
+        typer.Option(
+            "--password",
+            "-p",
+            prompt=True,
+            hide_input=True,
+            help="Account password (prompted if omitted).",
+        ),
+    ],
+) -> None:
+    """Log in and store the session for later commands."""
+    try:
+        with CronometerClient(email=email, password=password) as client:
+            session = client.login()
+    except CronometerError as exc:
+        _fail(str(exc))
+    path = save_session(session)
+    console.print(f"[green]Logged in[/green] as {session.email} (user id {session.user_id}).")
+    console.print(f"Session saved to [dim]{path}[/dim]")
+
+
+@app.command()
+def logout() -> None:
+    """Invalidate the remote session and remove the stored one."""
+    session = load_session()
+    if session is None:
+        console.print("Not logged in; nothing to do.")
+        return
+    try:
+        with CronometerClient(session) as client:
+            client.logout()
+    except CronometerError as exc:
+        err_console.print(f"[yellow]Warning:[/yellow] remote logout failed: {exc}")
+    delete_session()
+    console.print("[green]Logged out.[/green] Stored session removed.")
+
+
+@app.command()
+def whoami() -> None:
+    """Show the currently stored session."""
+    session = load_session()
+    if session is None:
+        console.print("Not logged in.")
+        raise typer.Exit(1)
+    console.print(f"{session.email or '<unknown>'} (user id {session.user_id})")
+    console.print(f"[dim]{default_session_path()}[/dim]")
+
+
+@app.command()
+def search(
+    query: Annotated[str, typer.Argument(help="Food name to search for.")],
+    limit: Annotated[int, typer.Option("--limit", "-n", min=1, max=200, help="Max results.")] = 25,
+    sources: Annotated[
+        Source, typer.Option("--sources", "-s", help="Cronometer source filter.")
+    ] = Source.ALL,
+    as_json: Annotated[
+        bool, typer.Option("--json", help="Print raw JSON instead of a table.")
+    ] = False,
+) -> None:
+    """Search foods, recipes and meals."""
+    try:
+        with _client_from_disk() as client:
+            results = client.search(query, max_results=limit, sources=sources)
+            if (updated := client.refresh_session()) is not None:
+                save_session(updated)
+    except NotAuthenticatedError as exc:
+        _fail(str(exc))
+    except CronometerError as exc:
+        _fail(str(exc))
+
+    if as_json:
+        console.print_json(json.dumps(results))
+        return
+
+    if not results:
+        console.print(f"No results for [bold]{query}[/bold].")
+        return
+
+    table = Table(title=f"Results for “{query}”", show_lines=False)
+    table.add_column("ID", justify="right", style="cyan", no_wrap=True)
+    table.add_column("Name")
+    table.add_column("Type", style="magenta")
+    table.add_column("Source", style="dim")
+    table.add_column("Measure", style="dim")
+    for item in results:
+        table.add_row(
+            str(item.get("id", "")),
+            item.get("displayString") or item.get("name", ""),
+            str(item.get("type", "")),
+            str(item.get("source", "")),
+            str(item.get("measureDisplayName", "")),
+        )
+    console.print(table)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

cronopy/client.py

@@ -0,0 +1,285 @@
+"""Minimal unofficial client for the Cronometer web API."""
+
+from __future__ import annotations
+
+import logging
+import re
+from enum import StrEnum
+from typing import Any
+
+import httpx
+
+from cronopy.session import Session
+
+BASE_URL = "https://cronometer.com"
+GWT_MODULE_BASE = f"{BASE_URL}/cronometer/"
+GWT_SERVICE = "com.cronometer.shared.rpc.CronometerService"
+log = logging.getLogger("cronopy.client")
+
+USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:155.0) Gecko/20100101 Firefox/155.0"
+
+
+class Source(StrEnum):
+    """Food source filter accepted by the search endpoint."""
+
+    ALL = "All"
+
+
+class CronometerError(Exception):
+    """Base error for the client."""
+
+
+class LoginError(CronometerError):
+    """Raised when authentication fails."""
+
+
+class NotAuthenticatedError(CronometerError):
+    """Raised when an action requires a session but none is available."""
+
+
+class CronometerClient:
+    """Client for the Cronometer web API.
+
+    Authenticate either with a previously saved ``session`` or with
+    ``email``/``password``. With credentials, login happens lazily on the
+    first call that needs a session. An expired session raises
+    :class:`NotAuthenticatedError`; the caller decides whether to ``login()``
+    again.
+    """
+
+    def __init__(
+        self,
+        session: Session | None = None,
+        *,
+        email: str | None = None,
+        password: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        if (email is None) != (password is None):
+            raise ValueError("email and password must be given together")
+        self._email = email
+        self._password = password
+        self._http = httpx.Client(
+            base_url=BASE_URL,
+            timeout=timeout,
+            headers={"User-Agent": USER_AGENT},
+            follow_redirects=True,
+            event_hooks={"request": [self._log_request], "response": [self._log_response]},
+        )
+        self.session: Session | None = None
+        if session is not None:
+            self._restore(session)
+
+    @staticmethod
+    def _log_request(request: httpx.Request) -> None:
+        if not log.isEnabledFor(logging.DEBUG):
+            return
+        log.debug("--> %s %s", request.method, request.url)
+        for k, v in request.headers.items():
+            if k.lower() == "cookie":
+                v = f"<{len(v)} bytes>"
+            log.debug("    %s: %s", k, v)
+        if request.content:
+            body = request.content.decode("utf-8", "replace")
+            body = re.sub(r"(password=)[^&]*", r"\1***", body)
+            log.debug("    body: %s", body[:1000])
+
+    @staticmethod
+    def _log_response(response: httpx.Response) -> None:
+        if not log.isEnabledFor(logging.DEBUG):
+            return
+        log.debug(
+            "<-- %s %s (%s)",
+            response.status_code,
+            response.url,
+            response.headers.get("content-type", ""),
+        )
+        for k, v in response.headers.multi_items():
+            if k.lower() == "set-cookie":
+                log.debug("    set-cookie: %s", v.split(";", 1)[0])
+        if not response.is_stream_consumed:
+            response.read()
+        text = response.text
+        if "javascript" in response.headers.get("content-type", ""):
+            log.debug("    body: <%d bytes of js>", len(text))
+        else:
+            log.debug("    body: %s", text[:1000])
+
+    def __enter__(self) -> CronometerClient:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _restore(self, session: Session) -> None:
+        self.session = session
+        log.debug("restoring session user_id=%s cookies=%s", session.user_id, list(session.cookies))
+        for name, value in session.cookies.items():
+            self._http.cookies.set(name, value, domain="cronometer.com", path="/")
+
+    def _snapshot(self, email: str | None, user_id: int) -> Session:
+        return Session(
+            user_id=user_id,
+            email=email,
+            cookies={name: value for name, value in self._http.cookies.items()},
+        )
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self.session is not None
+
+    def refresh_session(self) -> Session | None:
+        """Sync the live cookie jar back into ``self.session``.
+
+        Returns the updated session if any cookie changed (e.g. the AWS ALB
+        stickiness cookie is re-issued on every response), otherwise ``None``.
+        """
+        if self.session is None:
+            return None
+        current = {name: value for name, value in self._http.cookies.items()}
+        if current == self.session.cookies:
+            return None
+        changed = sorted(
+            k
+            for k in set(current) | set(self.session.cookies)
+            if current.get(k) != self.session.cookies.get(k)
+        )
+        log.debug("session cookies changed: %s", changed)
+        self.session = Session(
+            user_id=self.session.user_id, email=self.session.email, cookies=current
+        )
+        return self.session
+
+    @property
+    def has_credentials(self) -> bool:
+        return self._email is not None and self._password is not None
+
+    def _require_session(self) -> Session:
+        if self.session is None and self.has_credentials:
+            return self.login()
+        if self.session is None:
+            raise NotAuthenticatedError(
+                "Not logged in. Pass a session or email/password, or run `crono login`."
+            )
+        return self.session
+
+    def _gwt_hashes(self) -> tuple[str, str]:
+        """Fetch the current GWT permutation and RPC policy hash.
+
+        These change with every frontend deploy, so they are never persisted.
+        """
+        nocache = self._http.get("/cronometer/cronometer.nocache.js").text
+        m = re.search(r"'([0-9A-F]{32})'", nocache)
+        if not m:
+            raise CronometerError("Could not find GWT permutation hash")
+        permutation = m.group(1)
+        cache_js = self._http.get(f"/cronometer/{permutation}.cache.js").text
+        m = re.search(r"'app','([0-9A-F]{32})'", cache_js)
+        if not m:
+            raise CronometerError("Could not find GWT policy hash")
+        log.debug("gwt permutation=%s policy_hash=%s", permutation, m.group(1))
+        return permutation, m.group(1)
+
+    def _gwt_call(self, payload: str, permutation: str) -> str:
+        resp = self._http.post(
+            "/cronometer/app",
+            content=payload,
+            headers={
+                "Content-Type": "text/x-gwt-rpc; charset=UTF-8",
+                "X-GWT-Module-Base": GWT_MODULE_BASE,
+                "X-GWT-Permutation": permutation,
+            },
+        )
+        return resp.text
+
+    def login(self) -> Session:
+        """Authenticate with the constructor credentials and return the new session."""
+        email, password = self._email, self._password
+        if email is None or password is None:
+            raise LoginError("No credentials: construct the client with email and password")
+        self._http.cookies.clear()
+        self._http.get("/login/")
+
+        # Double-submit cookie CSRF: the token is the name of a 32-char cookie.
+        csrf_token = next(
+            (name for name in self._http.cookies if len(name) == 32 and name.islower()),
+            None,
+        )
+        log.debug("csrf token cookie: %s", csrf_token)
+        if csrf_token is None:
+            raise LoginError("Could not find anti-CSRF cookie on login page")
+
+        resp = self._http.post(
+            "/login",
+            data={
+                "anticsrf": csrf_token,
+                "password": password,
+                "username": email,
+                "userCode": "",
+            },
+            headers={
+                "Referer": f"{BASE_URL}/login/",
+                "X-Requested-With": "XMLHttpRequest",
+            },
+        )
+        if resp.status_code >= 400:
+            raise LoginError(f"Login request failed with HTTP {resp.status_code}")
+        if "sesnonce" not in self._http.cookies:
+            raise LoginError("Login failed: no session cookie returned (bad credentials?)")
+
+        self._http.get("/")
+        permutation, policy_hash = self._gwt_hashes()
+        auth_rpc = (
+            f"7|0|5|{GWT_MODULE_BASE}|{policy_hash}|{GWT_SERVICE}|authenticate|"
+            f"java.lang.Integer/3438268394|1|2|3|4|1|5|5|120|"
+        )
+        body = self._gwt_call(auth_rpc, permutation)
+        m = re.search(r"//OK\[(\d+),", body)
+        if not m:
+            raise LoginError(f"GWT authenticate failed: {body[:200]}")
+
+        self.session = self._snapshot(email, int(m.group(1)))
+        log.debug(
+            "authenticated user_id=%s cookies=%s", self.session.user_id, list(self.session.cookies)
+        )
+        return self.session
+
+    def logout(self) -> None:
+        session = self._require_session()
+        sesnonce = self._http.cookies.get("sesnonce") or session.cookies.get("sesnonce", "")
+        try:
+            permutation, policy_hash = self._gwt_hashes()
+            payload = (
+                f"7|0|6|{GWT_MODULE_BASE}|{policy_hash}|{GWT_SERVICE}|logout|"
+                f"java.lang.String/2004016611|{sesnonce}|1|2|3|4|1|5|6|"
+            )
+            self._gwt_call(payload, permutation)
+        finally:
+            self._http.cookies.clear()
+            self.session = None
+
+    def search(
+        self,
+        query: str,
+        max_results: int = 50,
+        sources: Source = Source.ALL,
+    ) -> Any:
+        session = self._require_session()
+        resp = self._http.get(
+            f"/api/v3/user/{session.user_id}/food-search/string",
+            params={
+                "query": query,
+                "maxResults": max_results,
+                "sources": Source(sources).value,
+                "categoryId": 0,
+                "selectedTab": "ALL",
+                "type": "All",
+            },
+        )
+        if resp.status_code in (401, 403):
+            raise NotAuthenticatedError("Session expired. Log in again.")
+        resp.raise_for_status()
+        return resp.json()

cronopy/session.py

@@ -0,0 +1,60 @@
+"""Persistent session storage for the Cronometer CLI."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+
+def default_session_path() -> Path:
+    base = os.environ.get("XDG_CONFIG_HOME")
+    root = Path(base) if base else Path.home() / ".config"
+    return root / "cronopy" / "session.json"
+
+
+@dataclass
+class Session:
+    user_id: int
+    email: str | None = None
+    cookies: dict[str, str] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Session:
+        return cls(
+            user_id=int(data["user_id"]),
+            email=data.get("email"),
+            cookies=dict(data.get("cookies") or {}),
+        )
+
+
+def load_session(path: Path | None = None) -> Session | None:
+    path = path or default_session_path()
+    if not path.exists():
+        return None
+    try:
+        return Session.from_dict(json.loads(path.read_text()))
+    except (ValueError, KeyError, TypeError):
+        return None
+
+
+def save_session(session: Session, path: Path | None = None) -> Path:
+    path = path or default_session_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(session.to_dict(), indent=2))
+    with contextlib.suppress(OSError):
+        path.chmod(0o600)
+    return path
+
+
+def delete_session(path: Path | None = None) -> bool:
+    path = path or default_session_path()
+    if path.exists():
+        path.unlink()
+        return True
+    return False

cronopy-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.3
+Name: cronopy
+Version: 0.1.0
+Summary: Unofficial cli for cronometer
+Author: Aron Radics
+Author-email: Aron Radics <radaron@radaron.hu>
+Requires-Dist: beautifulsoup4>=4.15.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.27.2
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# cronopy
+
+Unofficial cli for cronometer.
+
+## Install
+
+```sh
+uv sync
+```
+
+## Usage
+
+```sh
+crono login -e you@example.com      # password is prompted (or pass -p)
+crono search "chili" -n 10          # table output
+crono search "chili" --json         # raw JSON
+crono whoami
+crono logout
+```
+
+The session (cookies and user id) is stored in `~/.config/cronopy/session.json`
+(or `$XDG_CONFIG_HOME/cronopy/session.json`) and reused by every command.
+GWT hashes are fetched on demand and never persisted, since they change with
+each Cronometer frontend deploy.
+
+## Library
+
+With credentials (logs in lazily on first use):
+
+```python
+from cronopy import CronometerClient
+
+with CronometerClient(email="you@example.com", password="...") as client:
+    results = client.search("chili", max_results=10)
+```
+
+With a saved session (for example the one written by `crono login`):
+
+```python
+from cronopy import CronometerClient, load_session, save_session
+
+with CronometerClient(load_session()) as client:
+    results = client.search("chili", max_results=10)
+    if (updated := client.refresh_session()) is not None:
+        save_session(updated)
+```
+
+An expired session raises `NotAuthenticatedError`. Handle it by calling
+`client.login()` (needs credentials) and retrying:
+
+```python
+from cronopy import CronometerClient, NotAuthenticatedError, load_session
+
+with CronometerClient(load_session(), email="you@example.com", password="...") as client:
+    try:
+        results = client.search("chili")
+    except NotAuthenticatedError:
+        client.login()
+        results = client.search("chili")
+```

cronopy-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+cronopy/__init__.py,sha256=AYQJWduSA6XSovLl-N9C8JobDlhYLvdqZ7BBPkauG9I,522
+cronopy/cli.py,sha256=D6oqNwCLb-2iqR18l6nqUfIY619p3H4iNMSZcBCwmUQ,5237
+cronopy/client.py,sha256=ircFh5ly-97FCajRIHZ8tMLkGP-e0lSh3CmeDhg_R3g,10117
+cronopy/session.py,sha256=h2WjEOI11w3EaPXi-9QVQ38dr0vCIZmHGgEoaTbTfg0,1590
+cronopy-0.1.0.dist-info/WHEEL,sha256=7hzKWg-J8I3Buqyw5tBii5z_MmAVsDYXXijd_QAtNZ8,81
+cronopy-0.1.0.dist-info/entry_points.txt,sha256=VHNPvRKDDI-MTwBENFQdiaryIC79z6IGURzFpw-DXYQ,44
+cronopy-0.1.0.dist-info/METADATA,sha256=UG6iqJ-GyP9pZHTzqTB7AQqA33-8DoXgz_WbZ2ks3CA,1935
+cronopy-0.1.0.dist-info/RECORD,,

cronopy-0.1.0.dist-info/WHEEL

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

cronopy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+crono = cronopy.cli:main
+