nutrilog 0.1.0__py3-none-any.whl

nutrilog/__init__.py

@@ -0,0 +1,3 @@
+"""Nutrilog - Log meals, macronutrients, and calories directly to Google Health."""
+
+__version__ = "0.1.0"

nutrilog/auth.py

@@ -0,0 +1,148 @@
+"""OAuth 2.0 authentication manager for Google Health API."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Optional
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+
+from nutrilog.storage import (
+    delete_tokens,
+    get_credentials_path,
+    load_credentials,
+    load_tokens,
+    save_tokens,
+)
+
+SCOPES = [
+    "https://www.googleapis.com/auth/health.nutrition.writeonly",
+    "https://www.googleapis.com/auth/health.nutrition.readonly",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "openid",
+]
+
+TOKEN_URI = "https://oauth2.googleapis.com/token"
+AUTH_URI = "https://accounts.google.com/o/oauth2/auth"
+
+
+def get_client_config() -> Optional[dict[str, Any]]:
+    """Retrieve client credentials from env vars or credentials.json."""
+    env_id = os.getenv("NUTRILOG_CLIENT_ID") or os.getenv("GOOGLE_CLIENT_ID")
+    env_secret = os.getenv("NUTRILOG_CLIENT_SECRET") or os.getenv("GOOGLE_CLIENT_SECRET")
+    if env_id and env_secret:
+        return {
+            "installed": {
+                "client_id": env_id,
+                "client_secret": env_secret,
+                "auth_uri": AUTH_URI,
+                "token_uri": TOKEN_URI,
+                "redirect_uris": ["http://localhost"],
+            }
+        }
+
+    saved = load_credentials()
+    if saved:
+        return saved
+
+    creds_path = get_credentials_path()
+    if creds_path.exists():
+        import json
+
+        try:
+            return json.loads(creds_path.read_text(encoding="utf-8"))
+        except Exception:
+            return None
+
+    return None
+
+
+def _token_dict_from_creds(creds: Credentials) -> dict[str, Any]:
+    return {
+        "token": creds.token,
+        "refresh_token": creds.refresh_token,
+        "token_uri": creds.token_uri,
+        "client_id": creds.client_id,
+        "client_secret": creds.client_secret,
+        "scopes": creds.scopes,
+        "expiry": creds.expiry.isoformat() if creds.expiry else None,
+    }
+
+
+def get_credentials() -> Optional[Credentials]:
+    """Load valid credentials from storage, refreshing them if expired."""
+    token_data = load_tokens()
+    if not token_data:
+        return None
+
+    try:
+        creds = Credentials.from_authorized_user_info(token_data, SCOPES)
+    except Exception:
+        return None
+
+    if creds and creds.expired and creds.refresh_token:
+        try:
+            creds.refresh(Request())
+            save_tokens(_token_dict_from_creds(creds))
+        except Exception:
+            # If refresh fails, creds might be invalid
+            return None
+
+    return creds if (creds and (creds.valid or creds.token)) else None
+
+
+def login(
+    client_config_path: Optional[Path] = None,
+    port: int = 0,
+    open_browser: bool = True,
+) -> Credentials:
+    """Run local server OAuth 2.0 flow to obtain user credentials."""
+    client_config = None
+    if client_config_path and client_config_path.exists():
+        flow = InstalledAppFlow.from_client_secrets_file(
+            str(client_config_path),
+            scopes=SCOPES,
+        )
+    else:
+        client_config = get_client_config()
+        if not client_config:
+            raise ValueError(
+                "No OAuth client credentials found. Please provide a client_secrets.json file, "
+                "set NUTRILOG_CLIENT_ID and NUTRILOG_CLIENT_SECRET, or run 'nutrilog auth setup'."
+            )
+        flow = InstalledAppFlow.from_client_config(client_config, scopes=SCOPES)
+
+    creds = flow.run_local_server(
+        port=port,
+        open_browser=open_browser,
+        prompt="consent",
+        access_type="offline",
+    )
+
+    save_tokens(_token_dict_from_creds(creds))
+    return creds
+
+
+def get_auth_status() -> dict[str, Any]:
+    """Get the current authentication status and metadata."""
+    creds = get_credentials()
+    if not creds:
+        return {
+            "authenticated": False,
+            "has_saved_tokens": load_tokens() is not None,
+            "has_credentials_configured": get_client_config() is not None,
+        }
+
+    return {
+        "authenticated": True,
+        "expiry": creds.expiry.isoformat() if creds.expiry else None,
+        "scopes": creds.scopes,
+        "has_credentials_configured": True,
+    }
+
+
+def logout() -> bool:
+    """Log out by clearing stored user tokens."""
+    return delete_tokens()

nutrilog/auth_test.py

@@ -0,0 +1,120 @@
+"""Unit tests for nutrilog.auth."""
+
+from datetime import datetime, timezone
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+import pytest
+from google.oauth2.credentials import Credentials
+
+from nutrilog.auth import (
+    get_auth_status,
+    get_client_config,
+    get_credentials,
+    login,
+    logout,
+)
+from nutrilog.storage import ENV_CONFIG_DIR, save_credentials, save_tokens
+
+
+@pytest.fixture
+def temp_config_dir(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    custom_dir = tmp_path / "nutrilog_auth_test"
+    monkeypatch.setenv(ENV_CONFIG_DIR, str(custom_dir))
+    return custom_dir
+
+
+def test_get_client_config_from_env(monkeypatch: pytest.MonkeyPatch, temp_config_dir: Path):
+    monkeypatch.setenv("NUTRILOG_CLIENT_ID", "env-client-id")
+    monkeypatch.setenv("NUTRILOG_CLIENT_SECRET", "env-client-secret")
+
+    config = get_client_config()
+    assert config is not None
+    assert config["installed"]["client_id"] == "env-client-id"
+    assert config["installed"]["client_secret"] == "env-client-secret"
+
+
+def test_get_client_config_from_storage(monkeypatch: pytest.MonkeyPatch, temp_config_dir: Path):
+    monkeypatch.delenv("NUTRILOG_CLIENT_ID", raising=False)
+    monkeypatch.delenv("NUTRILOG_CLIENT_SECRET", raising=False)
+    monkeypatch.delenv("GOOGLE_CLIENT_ID", raising=False)
+    monkeypatch.delenv("GOOGLE_CLIENT_SECRET", raising=False)
+
+    assert get_client_config() is None
+
+    stored = {"installed": {"client_id": "stored-id", "client_secret": "stored-secret"}}
+    save_credentials(stored)
+    assert get_client_config() == stored
+
+
+def test_get_credentials_none_when_empty(temp_config_dir: Path):
+    assert get_credentials() is None
+    status = get_auth_status()
+    assert status["authenticated"] is False
+
+
+def test_get_credentials_valid(temp_config_dir: Path):
+    token_data = {
+        "token": "test-access-token",
+        "refresh_token": "test-refresh-token",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "client_id": "test-client-id",
+        "client_secret": "test-client-secret",
+        "scopes": ["https://www.googleapis.com/auth/health.nutrition.writeonly"],
+        "expiry": "2030-01-01T00:00:00Z",
+    }
+    save_tokens(token_data)
+
+    creds = get_credentials()
+    assert creds is not None
+    assert creds.token == "test-access-token"
+
+    status = get_auth_status()
+    assert status["authenticated"] is True
+
+
+def test_get_credentials_expired_refreshed(temp_config_dir: Path):
+    token_data = {
+        "token": "expired-token",
+        "refresh_token": "test-refresh-token",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "client_id": "test-client-id",
+        "client_secret": "test-client-secret",
+        "scopes": ["https://www.googleapis.com/auth/health.nutrition.writeonly"],
+        "expiry": "2020-01-01T00:00:00Z",
+    }
+    save_tokens(token_data)
+
+    with patch.object(Credentials, "refresh") as mock_refresh:
+        with patch.object(Credentials, "valid", return_value=True):
+            creds = get_credentials()
+            assert creds is not None
+            mock_refresh.assert_called_once()
+
+
+def test_logout(temp_config_dir: Path):
+    save_tokens({"token": "abc", "expiry": "2030-01-01T00:00:00Z"})
+    assert logout() is True
+    assert get_auth_status()["authenticated"] is False
+
+
+def test_login_flow(temp_config_dir: Path, monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setenv("NUTRILOG_CLIENT_ID", "test-id")
+    monkeypatch.setenv("NUTRILOG_CLIENT_SECRET", "test-secret")
+
+    mock_creds = MagicMock()
+    mock_creds.token = "new-token"
+    mock_creds.refresh_token = "new-refresh"
+    mock_creds.token_uri = "https://oauth2.googleapis.com/token"
+    mock_creds.client_id = "test-id"
+    mock_creds.client_secret = "test-secret"
+    mock_creds.scopes = ["scope1"]
+    mock_creds.expiry = datetime(2030, 1, 1, 0, 0, tzinfo=timezone.utc)
+
+    with patch("nutrilog.auth.InstalledAppFlow.from_client_config") as mock_flow_init:
+        mock_flow = MagicMock()
+        mock_flow.run_local_server.return_value = mock_creds
+        mock_flow_init.return_value = mock_flow
+
+        creds = login(port=0, open_browser=False)
+        assert creds == mock_creds
+        mock_flow.run_local_server.assert_called_once()