cave-cli 3.5.0__py3-none-any.whl

cave_cli/commands/version.py

@@ -0,0 +1,64 @@
+import argparse
+import re
+
+from cave_cli import __version__
+from cave_cli.utils.constants import CHAR_LINE
+from cave_cli.utils.env import parse_env
+from cave_cli.utils.logger import logger
+from cave_cli.utils.validate import find_app_dir, get_app
+
+
+def version(args: argparse.Namespace) -> None:
+    """
+    Usage:
+
+    - Prints the CLI version and app-specific versions if inside a CAVE app directory
+    """
+    logger.info(f"CAVE_CLI={__version__}")
+    print_app_versions()
+
+
+def print_app_versions() -> None:
+    try:
+        app_dir, app_name = get_app()
+    except SystemExit:
+        return
+
+    from pathlib import Path
+
+    logger.header(f"{app_name} versions:")
+
+    version_file = Path(app_dir) / "VERSION"
+    cave_app_version = (
+        version_file.read_text().strip()
+        if version_file.is_file()
+        else "Unknown"
+    )
+
+    req_file = Path(app_dir) / "requirements.txt"
+    cave_utils_version = "Unknown"
+    if req_file.is_file():
+        for line in req_file.read_text().splitlines():
+            if "cave_utils" in line:
+                parts = line.split("==")
+                if len(parts) == 2:
+                    cave_utils_version = f"v{parts[1].strip()}"
+                break
+
+    env_file = Path(app_dir) / ".env"
+    cave_static_version = "Unknown"
+    if env_file.is_file():
+        env_vars = parse_env(str(env_file))
+        static_url = env_vars.get("STATIC_APP_URL", "")
+        if "localhost" in static_url:
+            cave_static_version = "Local"
+        else:
+            static_path = env_vars.get("STATIC_APP_URL_PATH", "")
+            if static_path:
+                match = re.search(r"[0-9]+\.[0-9]+\.[0-9]+", static_path)
+                if match:
+                    cave_static_version = f"v{match.group(0)}"
+
+    logger.info(f"CAVE_APP={cave_app_version}")
+    logger.info(f"CAVE_STATIC={cave_static_version}")
+    logger.info(f"CAVE_UTILS={cave_utils_version}")

cave_cli/utils/cache.py

@@ -0,0 +1,235 @@
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def get_cache_dir() -> str:
+    """
+    Usage:
+
+    - Returns the platform-appropriate cache directory for cave_cli
+
+    Returns:
+
+    - ``path``:
+        - Type: str
+        - What: Absolute path to the cache directory (created if missing)
+
+    Notes:
+
+    - Windows: %LOCALAPPDATA%/cave_cli
+    - macOS: ~/Library/Caches/cave_cli
+    - Linux: $XDG_CACHE_HOME/cave_cli (fallback ~/.cache/cave_cli)
+    """
+    if os.name == "nt":
+        base_dir = os.environ.get("LOCALAPPDATA", os.path.expanduser("~"))
+    elif sys.platform == "darwin":
+        base_dir = os.path.expanduser("~/Library/Caches")
+    else:
+        base_dir = os.environ.get(
+            "XDG_CACHE_HOME", os.path.expanduser("~/.cache")
+        )
+
+    path = os.path.join(base_dir, "cave_cli")
+    os.makedirs(path, exist_ok=True)
+    return path
+
+
+def cache_path(name: str) -> str:
+    return os.path.join(get_cache_dir(), f"{name}.json")
+
+
+def load_entries(name: str) -> list[dict[str, str]]:
+    """
+    Usage:
+
+    - Loads cached entries from a JSON file
+
+    Requires:
+
+    - ``name``:
+        - Type: str
+        - What: The cache name (e.g. "mapbox_tokens", "admin_emails")
+
+    Returns:
+
+    - ``entries``:
+        - Type: list[dict[str, str]]
+        - What: A list of dicts with "label" and "value" keys
+    """
+    path = cache_path(name)
+    if not os.path.isfile(path):
+        return []
+    try:
+        data = json.loads(Path(path).read_text())
+        if isinstance(data, list):
+            return [
+                e
+                for e in data
+                if isinstance(e, dict) and "label" in e and "value" in e
+            ]
+    except (json.JSONDecodeError, OSError):
+        pass
+    return []
+
+
+def save_entry(name: str, label: str, value: str) -> None:
+    """
+    Usage:
+
+    - Appends a new labeled entry to a cache file, deduplicating by value
+
+    Requires:
+
+    - ``name``:
+        - Type: str
+        - What: The cache name
+
+    - ``label``:
+        - Type: str
+        - What: A user-provided label for the entry
+
+    - ``value``:
+        - Type: str
+        - What: The value to cache
+    """
+    entries = load_entries(name)
+    entries = [e for e in entries if e["value"] != value]
+    entries.append({"label": label, "value": value})
+    Path(cache_path(name)).write_text(
+        json.dumps(entries, indent=2) + "\n"
+    )
+
+
+def _mask_value(value: str) -> str:
+    if len(value) <= 4:
+        return "****"
+    return f"****{value[-4:]}"
+
+
+def prompt_cached_entry(
+    name: str,
+    prompt_new: str,
+    prompt_label: str = "Label for this entry: ",
+    mask: bool = False,
+    default: str | None = None,
+) -> str:
+    """
+    Usage:
+
+    - Displays cached entries and lets the user pick one, enter a new
+      value, use a default, or skip
+
+    Requires:
+
+    - ``name``:
+        - Type: str
+        - What: The cache name to load/save entries from
+
+    - ``prompt_new``:
+        - Type: str
+        - What: Prompt text shown when asking for a new value
+
+    Optional:
+
+    - ``prompt_label``:
+        - Type: str
+        - What: Prompt text shown when asking for a label for the new entry
+        - Default: "Label for this entry: "
+
+    - ``mask``:
+        - Type: bool
+        - What: Whether to mask values in the display (show last 4 chars)
+        - Default: False
+
+    - ``default``:
+        - Type: str | None
+        - What: A default value offered as an option
+        - Default: None
+
+    Returns:
+
+    - ``value``:
+        - Type: str
+        - What: The selected or entered value, or empty string if skipped
+    """
+    entries = load_entries(name)
+
+    if not entries:
+        try:
+            value = input(
+                f"{prompt_new}"
+                f"{f' Leave blank for default ({default})' if default else ''}"
+                ": "
+            )
+        except (EOFError, KeyboardInterrupt):
+            value = ""
+        if not value:
+            return default or ""
+        try:
+            label = input(prompt_label)
+        except (EOFError, KeyboardInterrupt):
+            label = ""
+        if not label:
+            label = value if not mask else f"entry-{len(entries) + 1}"
+        save_entry(name, label, value)
+        return value
+
+    print(f"\n{prompt_new}")
+    print(f"Saved entries:")
+    for i, entry in enumerate(entries, 1):
+        display = (
+            _mask_value(entry["value"]) if mask else entry["value"]
+        )
+        suffix = " (default)" if i == 1 else ""
+        print(f"  [{i}] {entry['label']} ({display}){suffix}")
+    print(f"  [N] Enter a new value")
+    if default is not None:
+        print(f"  [D] Use default ({default})")
+    else:
+        print(f"  [S] Skip")
+
+    max_idx = len(entries)
+    range_str = str(max_idx) if max_idx == 1 else f"1-{max_idx}"
+    skip_key = "/D" if default else "/S"
+    while True:
+        try:
+            choice = input(f"Choose [{range_str}/N{skip_key}]: ")
+        except (EOFError, KeyboardInterrupt):
+            return default or ""
+        choice = choice.strip()
+
+        if not choice:
+            return entries[0]["value"]
+
+        if choice.upper() == "N":
+            try:
+                value = input(f"{prompt_new}: ")
+            except (EOFError, KeyboardInterrupt):
+                return default or ""
+            if not value:
+                return default or ""
+            try:
+                label = input(prompt_label)
+            except (EOFError, KeyboardInterrupt):
+                label = ""
+            if not label:
+                label = (
+                    value if not mask else f"entry-{len(entries) + 1}"
+                )
+            save_entry(name, label, value)
+            return value
+
+        if choice.upper() == "S" and default is None:
+            return ""
+
+        if choice.upper() == "D" and default is not None:
+            return default
+
+        if choice.isdigit():
+            idx = int(choice)
+            if 1 <= idx <= max_idx:
+                return entries[idx - 1]["value"]
+
+        print(f"Invalid choice. Please try again.")

cave_cli/utils/constants.py

@@ -0,0 +1,43 @@
+import re
+from pathlib import Path
+
+HTTPS_URL: str = "https://github.com/MIT-CAVE/cave_app.git"
+MIN_DOCKER_VERSION: str = "23.0.6"
+CHAR_LINE: str = "============================="
+
+VALID_NAME_RE: re.Pattern = re.compile(r"^[a-z0-9_-]+$")
+INVALID_NAME_START_RE: re.Pattern = re.compile(r"^[-_]+.*$")
+INVALID_NAME_END_RE: re.Pattern = re.compile(r"^.*[-_]+$")
+INVALID_NAME_HYPHEN_UNDER_RE: re.Pattern = re.compile(r"(-_)+")
+INVALID_NAME_UNDER_HYPHEN_RE: re.Pattern = re.compile(r"(_-)+")
+
+IP_PORT_RE: re.Pattern = re.compile(
+    r"([0-9]{1,3}\.)+([0-9]{1,3}):[0-9][0-9][0-9][0-9]+"
+)
+
+CURRENT_ENV_VARIABLES: tuple[str, ...] = (
+    "DATABASE_IMAGE",
+    "DATABASE_PASSWORD",
+    "DJANGO_ADMIN_EMAIL",
+    "DJANGO_ADMIN_FIRST_NAME",
+    "DJANGO_ADMIN_LAST_NAME",
+    "DJANGO_ADMIN_PASSWORD",
+    "DJANGO_ADMIN_USERNAME",
+    "SECRET_KEY",
+    "STATIC_APP_URL",
+    "STATIC_APP_URL_PATH",
+)
+
+RETIRED_ENV_VARIABLES: tuple[str, ...] = (
+    "DATABASE_HOST",
+    "DATABASE_PORT",
+    "DATABASE_NAME",
+    "DATABASE_USER",
+)
+
+VALID_REPOS: tuple[str, ...] = (
+    "cave_app",
+    "cave_static",
+    "cave_cli",
+    "cave_utils",
+)