gflow-cli 0.2.0a1__py3-none-any.whl

flow_cli/config.py

@@ -0,0 +1,116 @@
+"""Process-wide configuration via `pydantic-settings`.
+
+All knobs are env-var-driven (prefix `FLOW_CLI_`), with a `.env` fallback
+loaded from CWD or `$FLOW_CLI_HOME/.env`. Validated at startup; bad values
+fail loudly with the offending key + the rule it violated.
+
+Resolution precedence (highest first):
+    1. CLI flag (passed at call site, not here)
+    2. Environment variable
+    3. `.env` file (CWD wins over $FLOW_CLI_HOME/.env)
+    4. Built-in default (from `flow_cli.paths`)
+
+Use `get_settings()` to access the cached singleton. Tests should call
+`reset_settings()` between cases.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+from functools import lru_cache
+from pathlib import Path
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from flow_cli import paths
+
+
+class LogLevel(StrEnum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+
+
+class LogFormat(StrEnum):
+    AUTO = "auto"
+    TEXT = "text"
+    JSON = "json"
+
+
+class Provider(StrEnum):
+    FLOW = "flow"
+    OFFICIAL = "official"  # planned v0.3+ via googleapis/python-genai
+
+
+class Settings(BaseSettings):
+    """All flow-cli configuration. Build via `Settings()` (or `get_settings()`)."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="FLOW_CLI_",
+        env_file=(".env",),
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    # --- paths ------------------------------------------------------------
+    home: Path = Field(
+        default_factory=paths.default_home,
+        description="Root for profiles, config.toml, etc.",
+    )
+    output_dir: Path = Field(
+        default_factory=paths.default_output_dir,
+        description="Where generated assets land.",
+    )
+
+    # --- profile ----------------------------------------------------------
+    profile: str | None = Field(
+        default=None,
+        description=(
+            "Default profile name. None = resolve from config.toml or "
+            "auto-pick the only profile present."
+        ),
+    )
+
+    # --- provider ---------------------------------------------------------
+    provider: Provider = Provider.FLOW
+    gemini_api_key: str | None = Field(
+        default=None,
+        description="Required when provider=official (v0.3+).",
+    )
+
+    # --- runtime ----------------------------------------------------------
+    timeout_seconds: int = Field(default=600, ge=1, le=3600)
+    concurrency: int = Field(default=1, ge=1, le=16)
+    headless: bool = Field(
+        default=True,
+        description=(
+            "Run the Playwright Chromium headless. Set to False if reCAPTCHA "
+            "fails to mint tokens (Google sometimes detects headless)."
+        ),
+    )
+
+    # --- logging ----------------------------------------------------------
+    log_level: LogLevel = LogLevel.INFO
+    log_format: LogFormat = LogFormat.AUTO
+
+    # --- derived path helpers --------------------------------------------
+
+    def profile_subdir(self, name: str) -> Path:
+        return paths.profile_subdir(self.home, name)
+
+    def config_file(self) -> Path:
+        return paths.config_file(self.home)
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> Settings:
+    """Cached settings singleton. Tests should call `reset_settings()`."""
+    return Settings()
+
+
+def reset_settings() -> None:
+    """Clear the cache. Call between tests that munge env vars."""
+    get_settings.cache_clear()

flow_cli/manifest.py

@@ -0,0 +1,58 @@
+"""TSV manifest parser for `gflow video batch`.
+
+Format (tab-separated, optional ``# ``-prefixed comments + blank lines)::
+
+    start_image\tprompt\tend_image\taspect\toutput_path
+
+Columns:
+
+- start_image: path to PNG/JPG (empty -> T2V)
+- prompt: required, non-empty
+- end_image: optional second-frame for transition I2V (not yet wired in MVP)
+- aspect: 9:16 | 16:9 | 1:1 (default 9:16)
+- output_path: optional output file path; empty -> default scheme
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from flow_cli.api.video import Aspect
+
+
+@dataclass(frozen=True)
+class ManifestEntry:
+    prompt: str
+    start_image: Path | None = None
+    end_image: Path | None = None
+    aspect: Aspect = Aspect.PORTRAIT
+    output_path: Path | None = None
+
+
+def parse_manifest(path: Path) -> list[ManifestEntry]:
+    """Parse a TSV manifest file. Raises ValueError on bad rows."""
+    entries: list[ManifestEntry] = []
+    text = path.read_text(encoding="utf-8")
+    for lineno, raw in enumerate(text.splitlines(), start=1):
+        stripped = raw.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        cols = raw.split("\t")
+        # Pad to 5 columns so unpacking is always safe.
+        while len(cols) < 5:
+            cols.append("")
+        start_image_s, prompt, end_image_s, aspect_s, output_s = (c.strip() for c in cols[:5])
+        if not prompt:
+            raise ValueError(f"line {lineno}: prompt is required (got empty)")
+        aspect = Aspect.from_cli(aspect_s) if aspect_s else Aspect.PORTRAIT
+        entries.append(
+            ManifestEntry(
+                prompt=prompt,
+                start_image=Path(start_image_s) if start_image_s else None,
+                end_image=Path(end_image_s) if end_image_s else None,
+                aspect=aspect,
+                output_path=Path(output_s) if output_s else None,
+            )
+        )
+    return entries

flow_cli/paths.py

@@ -0,0 +1,82 @@
+"""XDG-aware default paths for flow-cli, via `platformdirs`.
+
+Single source of truth for where things live on disk:
+
+  * **profiles + config** under `<user_data_dir>/flow-cli/`
+    - Windows: `%LOCALAPPDATA%\\flow-cli\\`
+    - macOS:   `~/Library/Application Support/flow-cli/`
+    - Linux:   `$XDG_DATA_HOME/flow-cli/` (typically `~/.local/share/flow-cli/`)
+
+  * **downloads** under `<user_downloads_dir>/flow-cli/`
+    - Windows: `%USERPROFILE%\\Downloads\\flow-cli\\`
+    - macOS:   `~/Downloads/flow-cli/`
+    - Linux:   `$XDG_DOWNLOAD_DIR/flow-cli/` (typically `~/Downloads/flow-cli/`)
+
+These are the defaults — overridable per-process via env vars
+`FLOW_CLI_HOME` and `FLOW_CLI_OUTPUT_DIR`. Resolution lives in
+`flow_cli.config.Settings`.
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import date
+from pathlib import Path
+
+from platformdirs import user_data_dir, user_downloads_dir
+
+# Allow only alphanumerics, hyphens, and underscores up to 128 chars.
+# Prevents path traversal via API-returned job IDs.
+_SAFE_ID_RE = re.compile(r"^[\w\-]{1,128}$")
+
+APP_NAME = "flow-cli"
+APP_AUTHOR = "ffroliva"  # Windows-only; Linux/macOS ignore this.
+
+
+def default_home() -> Path:
+    """Default `FLOW_CLI_HOME` — profiles + config.toml live here."""
+    return Path(user_data_dir(APP_NAME, APP_AUTHOR, ensure_exists=False))
+
+
+def default_output_dir() -> Path:
+    """Default `FLOW_CLI_OUTPUT_DIR` — generated assets land here."""
+    return Path(user_downloads_dir()) / APP_NAME
+
+
+def profile_subdir(home: Path, name: str) -> Path:
+    """Where profile <name> lives under <home>."""
+    return home / f"profile_{name}"
+
+
+def config_file(home: Path) -> Path:
+    """Where the per-user config TOML lives."""
+    return home / "config.toml"
+
+
+def _validate_job_id(job_id: str) -> str:
+    if not _SAFE_ID_RE.match(job_id):
+        raise ValueError(f"Unsafe job_id returned by API: {job_id!r}")
+    return job_id
+
+
+def video_output_path(
+    output_dir: Path,
+    *,
+    job_id: str,
+    on: date | None = None,
+) -> Path:
+    """`<output_dir>/videos/<YYYY-MM-DD>/<job_id>.mp4`."""
+    on = on or date.today()
+    return output_dir / "videos" / on.isoformat() / f"{_validate_job_id(job_id)}.mp4"
+
+
+def image_output_path(
+    output_dir: Path,
+    *,
+    job_id: str,
+    index: int = 1,
+    on: date | None = None,
+) -> Path:
+    """`<output_dir>/images/<YYYY-MM-DD>/<job_id>_<index>.png`."""
+    on = on or date.today()
+    return output_dir / "images" / on.isoformat() / f"{_validate_job_id(job_id)}_{index}.png"

flow_cli/profile_store.py

@@ -0,0 +1,226 @@
+"""Profile inventory + default-profile persistence.
+
+Single source of truth for: which Google sessions exist, which one to use
+when no `--profile` flag is given, and how to set/clear that default.
+
+Storage layout under $FLOW_CLI_HOME (default: see flow_cli.auth.default_profile_root):
+    ./profile_<name>/        ← Chromium persistent context per profile
+    ./config.toml            ← `default_profile = "<name>"`
+
+Resolution precedence (highest first):
+    1. Explicit CLI --profile flag
+    2. FLOW_CLI_PROFILE env var
+    3. config.toml's default_profile
+    4. Auto-select if exactly one profile exists
+    5. Raise NoDefaultProfileError with the list of available profiles
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import tomllib
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+
+from flow_cli.auth import default_profile_root, profile_dir, status
+
+CONFIG_FILENAME = "config.toml"
+PROFILE_DIR_PREFIX = "profile_"
+
+
+@dataclass(frozen=True)
+class ProfileMeta:
+    """Snapshot of one profile on disk."""
+
+    name: str
+    profile_dir: Path
+    cookies_present: bool
+    last_used_at: datetime | None
+    is_default: bool
+
+
+class NoDefaultProfileError(RuntimeError):
+    """Raised when profile resolution can't pick exactly one profile."""
+
+    def __init__(self, available: list[str]):
+        self.available = available
+        msg = (
+            "Cannot pick a default profile.\n"
+            f"Available: {', '.join(available) if available else '(none)'}\n"
+            "Run `gflow auth use <name>`, set FLOW_CLI_PROFILE, or pass --profile."
+        )
+        super().__init__(msg)
+
+
+class NoProfilesError(RuntimeError):
+    """Raised when no profiles exist at all (caller should trigger login)."""
+
+
+def config_path() -> Path:
+    """Path to the user-level config.toml (under $FLOW_CLI_HOME)."""
+    return default_profile_root() / CONFIG_FILENAME
+
+
+def list_profiles() -> list[ProfileMeta]:
+    """Discover every `profile_*` directory under $FLOW_CLI_HOME.
+
+    Returns them sorted by name. Each entry includes whether it has a Chromium
+    cookies file (a coarse "has session" probe — actual validity is only known
+    by hitting the live API).
+    """
+    root = default_profile_root()
+    if not root.exists():
+        return []
+    default_name = _read_default_profile_name()
+    out: list[ProfileMeta] = []
+    for entry in sorted(root.iterdir()):
+        if not entry.is_dir() or not entry.name.startswith(PROFILE_DIR_PREFIX):
+            continue
+        name = entry.name[len(PROFILE_DIR_PREFIX) :]
+        s = status(name)
+        last_used = _last_modified(entry)
+        out.append(
+            ProfileMeta(
+                name=name,
+                profile_dir=entry,
+                cookies_present=bool(s["cookies_present"]),
+                last_used_at=last_used,
+                is_default=(name == default_name),
+            )
+        )
+    return out
+
+
+def has_any_profiles() -> bool:
+    return len(list_profiles()) > 0
+
+
+def get_default_profile() -> str | None:
+    """Resolved default profile name, or None if no rule applies.
+
+    Order:
+      1. config.toml `default_profile`
+      2. Auto: if exactly one profile exists, that one is the de-facto default.
+      3. None.
+    """
+    explicit = _read_default_profile_name()
+    if explicit:
+        return explicit
+    profiles = list_profiles()
+    if len(profiles) == 1:
+        return profiles[0].name
+    return None
+
+
+def set_default_profile(name: str) -> Path:
+    """Persist `name` as the default profile in config.toml. Returns config path.
+
+    Validates the profile dir exists; raises FileNotFoundError otherwise so
+    typos don't silently set an unusable default.
+    """
+    pdir = profile_dir(name)
+    if not pdir.exists():
+        raise FileNotFoundError(
+            f"Profile dir not found: {pdir}\nRun `gflow auth login --profile {name}` first."
+        )
+    cfg = config_path()
+    cfg.parent.mkdir(parents=True, exist_ok=True)
+    # Single-key file — keep it minimal so future keys can be added cleanly.
+    existing = _load_config()
+    existing["default_profile"] = name
+    cfg.write_text(_dump_config(existing), encoding="utf-8")
+    return cfg
+
+
+def clear_default_profile() -> None:
+    """Remove the default_profile key. Other config keys (future) preserved."""
+    cfg = config_path()
+    if not cfg.exists():
+        return
+    existing = _load_config()
+    existing.pop("default_profile", None)
+    if existing:
+        cfg.write_text(_dump_config(existing), encoding="utf-8")
+    else:
+        cfg.unlink()
+
+
+def delete_profile(name: str) -> Path:
+    """Hard-delete the profile dir. Clears it as default if it was set."""
+    pdir = profile_dir(name)
+    if not pdir.exists():
+        raise FileNotFoundError(f"Profile dir not found: {pdir}")
+    shutil.rmtree(pdir, ignore_errors=False)
+    if _read_default_profile_name() == name:
+        clear_default_profile()
+    return pdir
+
+
+def resolve_profile(cli_flag: str | None) -> str:
+    """Apply the full precedence chain. Raises if no profile can be picked."""
+    if cli_flag:
+        return cli_flag
+    env = os.environ.get("FLOW_CLI_PROFILE")
+    if env:
+        return env
+    default = get_default_profile()
+    if default:
+        return default
+    profiles = list_profiles()
+    if not profiles:
+        raise NoProfilesError("No profiles found. Run `gflow auth login` to create one.")
+    raise NoDefaultProfileError([p.name for p in profiles])
+
+
+# --- internals --------------------------------------------------------------
+
+
+def _read_default_profile_name() -> str | None:
+    cfg = _load_config()
+    val = cfg.get("default_profile")
+    return val if isinstance(val, str) and val else None
+
+
+def _load_config() -> dict[str, object]:
+    cfg = config_path()
+    if not cfg.exists():
+        return {}
+    try:
+        with cfg.open("rb") as f:
+            return dict(tomllib.load(f))
+    except (tomllib.TOMLDecodeError, OSError):
+        return {}
+
+
+def _dump_config(data: dict[str, object]) -> str:
+    """Tiny TOML serialiser — only handles flat string keys (sufficient for now).
+
+    Avoids adding `tomli-w` as a dependency. Switch to it if config grows
+    nested tables or non-string values.
+    """
+    lines: list[str] = []
+    for key, value in sorted(data.items()):
+        if not isinstance(value, str):
+            raise TypeError(
+                f"Only string values are supported in config.toml; "
+                f"got {type(value).__name__} for key {key!r}."
+            )
+        # Escape backslashes and double-quotes in TOML basic string.
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        lines.append(f'{key} = "{escaped}"')
+    return "\n".join(lines) + "\n"
+
+
+def _last_modified(path: Path) -> datetime | None:
+    try:
+        # Best-effort: latest mtime among the cookies file or the dir itself.
+        candidates = [path]
+        for sub in (path / "Default" / "Cookies", path / "Cookies"):
+            if sub.exists():
+                candidates.append(sub)
+        ts = max(p.stat().st_mtime for p in candidates)
+        return datetime.fromtimestamp(ts, tz=UTC)
+    except OSError:
+        return None