alloc 0.0.1__py3-none-any.whl

alloc/config.py

@@ -0,0 +1,124 @@
+"""Alloc CLI configuration — persistent config file + env var overrides."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+def _config_dir() -> Path:
+    # Compute dynamically so tests and containerized runs can override HOME.
+    return Path.home() / ".alloc"
+
+
+def _config_file() -> Path:
+    return _config_dir() / "config.json"
+
+_DEFAULT_API_URL = "https://alloc-production-ffc2.up.railway.app"
+_DEFAULT_SUPABASE_URL = "https://stysqykttruzpcnzxshp.supabase.co"
+_DEFAULT_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InN0eXNxeWt0dHJ1enBjbnp4c2hwIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA1ODgzOTQsImV4cCI6MjA4NjE2NDM5NH0.cHOBh5ei90Vj359TesKJ5GMZlyLoWFkMoNYs-HrKAtw"
+
+
+def load_config() -> dict:
+    """Read ~/.alloc/config.json or return empty dict."""
+    try:
+        cfg_file = _config_file()
+        if cfg_file.exists():
+            return json.loads(cfg_file.read_text())
+    except Exception:
+        pass
+    return {}
+
+
+def save_config(data: dict) -> None:
+    """Write data to ~/.alloc/config.json. Creates dir if needed."""
+    try:
+        cfg_dir = _config_dir()
+        cfg_dir.mkdir(parents=True, exist_ok=True)
+        os.chmod(cfg_dir, 0o700)
+        cfg_file = _config_file()
+        cfg_file.write_text(json.dumps(data, indent=2) + "\n")
+        os.chmod(cfg_file, 0o600)
+    except Exception:
+        pass
+
+
+def get_token() -> str:
+    """Auth token. Env var takes precedence over config file."""
+    env = os.environ.get("ALLOC_TOKEN", "")
+    if env:
+        return env
+    return load_config().get("token", "")
+
+
+def get_api_url() -> str:
+    """API URL. Env var > config file > default."""
+    env = os.environ.get("ALLOC_API_URL", "")
+    if env:
+        return env
+    return load_config().get("api_url", _DEFAULT_API_URL)
+
+
+def get_supabase_url() -> str:
+    """Supabase URL. Env var > default."""
+    return os.environ.get("ALLOC_SUPABASE_URL", _DEFAULT_SUPABASE_URL)
+
+
+def get_supabase_anon_key() -> str:
+    """Supabase anon key. Env var > default."""
+    return os.environ.get("ALLOC_SUPABASE_ANON_KEY", _DEFAULT_SUPABASE_ANON_KEY)
+
+
+def should_upload() -> bool:
+    """Whether to upload results to the Alloc dashboard."""
+    return os.environ.get("ALLOC_UPLOAD", "").lower() in ("1", "true", "yes")
+
+
+def try_refresh_access_token() -> Optional[str]:
+    """Attempt to refresh the saved access token using refresh_token.
+
+    Returns the new access token on success, otherwise None.
+
+    Notes:
+    - If ALLOC_TOKEN is set, this function returns None (env tokens can't be updated).
+    - This calls Supabase directly, so it requires ALLOC_SUPABASE_URL and
+      ALLOC_SUPABASE_ANON_KEY (or defaults) to be correct.
+    """
+    if os.environ.get("ALLOC_TOKEN"):
+        return None
+
+    cfg = load_config()
+    refresh_token = (cfg.get("refresh_token") or "").strip()
+    if not refresh_token:
+        return None
+
+    # Local import to keep config module import-time side effects minimal.
+    import httpx
+
+    supabase_url = get_supabase_url()
+    anon_key = get_supabase_anon_key()
+
+    try:
+        with httpx.Client(timeout=15) as client:
+            resp = client.post(
+                f"{supabase_url}/auth/v1/token?grant_type=refresh_token",
+                json={"refresh_token": refresh_token},
+                headers={
+                    "apikey": anon_key,
+                    "Content-Type": "application/json",
+                },
+            )
+            resp.raise_for_status()
+            data = resp.json()
+    except Exception:
+        return None
+
+    access_token = (data.get("access_token") or "").strip()
+    if not access_token:
+        return None
+
+    cfg["token"] = access_token
+    cfg["refresh_token"] = (data.get("refresh_token") or refresh_token).strip()
+    save_config(cfg)
+    return access_token

alloc/context.py

@@ -0,0 +1,191 @@
+"""Context autodiscovery — capture environment metadata into the artifact.
+
+All discovery functions are fail-safe: they return None on any error.
+The artifact gets a `context` dict with optional fields. Never fails,
+never slows down the CLI.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from typing import Optional
+
+
+def discover_context() -> dict:
+    """Discover all available environment context.
+
+    Returns a dict with optional keys: git, container, ray.
+    Only includes sections where data was found.
+    """
+    ctx = {}  # type: dict
+
+    git = _discover_git()
+    if git:
+        ctx["git"] = git
+
+    container = _discover_container()
+    if container:
+        ctx["container"] = container
+
+    ray = _discover_ray()
+    if ray:
+        ctx["ray"] = ray
+
+    return ctx
+
+
+def _discover_git() -> Optional[dict]:
+    """Discover git context: commit SHA, branch, repo name."""
+    try:
+        # Check if we're in a git repo
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode != 0:
+            return None
+
+        git = {}  # type: dict
+
+        # Commit SHA
+        sha = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if sha.returncode == 0 and sha.stdout.strip():
+            git["commit_sha"] = sha.stdout.strip()
+
+        # Branch name
+        branch = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if branch.returncode == 0 and branch.stdout.strip():
+            git["branch"] = branch.stdout.strip()
+
+        # Repo name (from remote origin URL or top-level dir name)
+        remote = subprocess.run(
+            ["git", "config", "--get", "remote.origin.url"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if remote.returncode == 0 and remote.stdout.strip():
+            git["repo_url"] = remote.stdout.strip()
+            git["repo_name"] = _repo_name_from_url(remote.stdout.strip())
+        else:
+            # Fallback: use the top-level directory name
+            toplevel = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if toplevel.returncode == 0 and toplevel.stdout.strip():
+                git["repo_name"] = os.path.basename(toplevel.stdout.strip())
+
+        return git if git else None
+    except Exception:
+        return None
+
+
+def _repo_name_from_url(url: str) -> str:
+    """Extract repo name from a git remote URL.
+
+    Handles:
+      git@github.com:org/repo.git → repo
+      https://github.com/org/repo.git → repo
+      https://github.com/org/repo → repo
+    """
+    # Strip trailing .git
+    name = url.rstrip("/")
+    if name.endswith(".git"):
+        name = name[:-4]
+    # Take the last path component
+    return name.rsplit("/", 1)[-1].rsplit(":", 1)[-1]
+
+
+def _discover_container() -> Optional[dict]:
+    """Discover container context: container ID, image name."""
+    try:
+        container = {}  # type: dict
+
+        # Check for /.dockerenv (Docker) or /run/.containerenv (Podman)
+        in_docker = os.path.isfile("/.dockerenv")
+        in_podman = os.path.isfile("/run/.containerenv")
+
+        if not in_docker and not in_podman:
+            # Also check cgroup for container evidence
+            if not _check_cgroup_for_container():
+                return None
+
+        # Container ID from /proc/self/cgroup or hostname
+        cid = _read_container_id()
+        if cid:
+            container["container_id"] = cid
+
+        # Image name from env var (commonly set by orchestrators)
+        image = os.environ.get("CONTAINER_IMAGE") or os.environ.get("DOCKER_IMAGE")
+        if image:
+            container["image"] = image
+
+        container["runtime"] = "podman" if in_podman else "docker"
+
+        return container if container else None
+    except Exception:
+        return None
+
+
+def _check_cgroup_for_container() -> bool:
+    """Check /proc/self/cgroup for container evidence."""
+    try:
+        with open("/proc/self/cgroup", "r") as f:
+            content = f.read()
+        return "docker" in content or "containerd" in content or "kubepods" in content
+    except Exception:
+        return False
+
+
+def _read_container_id() -> Optional[str]:
+    """Read container ID from /proc/self/cgroup or hostname."""
+    # Try /proc/self/cgroup first
+    try:
+        with open("/proc/self/cgroup", "r") as f:
+            for line in f:
+                parts = line.strip().split("/")
+                for part in reversed(parts):
+                    # Container IDs are 64-char hex strings
+                    cleaned = part.split("-")[-1].rstrip(".scope")
+                    if len(cleaned) == 64 and all(c in "0123456789abcdef" for c in cleaned):
+                        return cleaned[:12]  # Short form
+    except Exception:
+        pass
+
+    # Fallback: hostname inside a container is often the short container ID
+    try:
+        hostname = os.environ.get("HOSTNAME", "")
+        if len(hostname) == 12 and all(c in "0123456789abcdef" for c in hostname):
+            return hostname
+    except Exception:
+        pass
+
+    return None
+
+
+def _discover_ray() -> Optional[dict]:
+    """Discover Ray context from environment variables."""
+    try:
+        ray = {}  # type: dict
+
+        job_id = os.environ.get("RAY_JOB_ID")
+        if job_id:
+            ray["job_id"] = job_id
+
+        cluster = os.environ.get("RAY_CLUSTER_NAME") or os.environ.get("RAY_ADDRESS")
+        if cluster:
+            ray["cluster"] = cluster
+
+        node_id = os.environ.get("RAY_NODE_ID")
+        if node_id:
+            ray["node_id"] = node_id
+
+        return ray if ray else None
+    except Exception:
+        return None