| from __future__ import annotations
|
|
|
| import argparse
|
| import json
|
| import shutil
|
| import subprocess
|
| import sys
|
| from dataclasses import dataclass
|
| from pathlib import Path
|
| from typing import Sequence
|
|
|
| ROOT_DIR = Path(__file__).resolve().parent.parent
|
| if str(ROOT_DIR) not in sys.path:
|
| sys.path.insert(0, str(ROOT_DIR))
|
|
|
| from scripts.verify_site import verify_site
|
|
|
|
|
| DEFAULT_SITE_URL = "https://arabic-translator-mu.vercel.app"
|
| DIRECT_CLOUD_ENV_KEYS = ["ENABLE_DIRECT_CLOUD_TTS", "HF_API_TOKEN", "HF_TTS_MODEL", "DEFAULT_VOICE_ID"]
|
| VERCEL_COMMAND = shutil.which("vercel") or shutil.which("vercel.cmd") or "vercel"
|
|
|
|
|
| @dataclass
|
| class CommandResult:
|
| command: list[str]
|
| returncode: int
|
| stdout: str
|
| stderr: str
|
|
|
|
|
| def normalize_url(value: str) -> str:
|
| return value.rstrip("/")
|
|
|
|
|
| def looks_like_hf_space(url: str) -> bool:
|
| host = url.split("://", 1)[-1].split("/", 1)[0].lower()
|
| return host == "hf.space" or host.endswith(".hf.space")
|
|
|
|
|
| def validate_worker_url(worker_url: str) -> str:
|
| worker_url = normalize_url(worker_url.strip())
|
| if not worker_url.startswith("https://"):
|
| raise ValueError("WORKER_BASE_URL must start with https://")
|
| if "localhost" in worker_url or "127.0.0.1" in worker_url:
|
| raise ValueError("WORKER_BASE_URL must be public, not localhost")
|
| if ".vercel.app" in worker_url:
|
| raise ValueError("WORKER_BASE_URL must point at the worker, not the Vercel site")
|
| if not looks_like_hf_space(worker_url):
|
| raise ValueError("WORKER_BASE_URL should be a Hugging Face Space URL ending in .hf.space")
|
| return worker_url
|
|
|
|
|
| def run_command(command: Sequence[str], input_text: str | None = None, check: bool = True) -> CommandResult:
|
| completed = subprocess.run(
|
| list(command),
|
| input=input_text,
|
| text=True,
|
| capture_output=True,
|
| )
|
| result = CommandResult(
|
| command=list(command),
|
| returncode=completed.returncode,
|
| stdout=completed.stdout,
|
| stderr=completed.stderr,
|
| )
|
| if check and completed.returncode != 0:
|
| message = completed.stderr.strip() or completed.stdout.strip() or f"command failed with {completed.returncode}"
|
| raise RuntimeError(f"{' '.join(command)} failed: {message}")
|
| return result
|
|
|
|
|
| def remove_vercel_env(name: str, environment: str) -> CommandResult:
|
| result = run_command([VERCEL_COMMAND, "env", "rm", name, environment, "--yes"], check=False)
|
| combined = f"{result.stdout}\n{result.stderr}"
|
| if result.returncode != 0 and "env_not_found" not in combined and "was not found" not in combined:
|
| message = result.stderr.strip() or result.stdout.strip() or f"command failed with {result.returncode}"
|
| raise RuntimeError(f"vercel env rm {name} failed: {message}")
|
| return result
|
|
|
|
|
| def add_vercel_env(name: str, value: str, environment: str) -> CommandResult:
|
| return run_command([VERCEL_COMMAND, "env", "add", name, environment], input_text=f"{value}\n")
|
|
|
|
|
| def configure_vercel_worker(
|
| worker_url: str,
|
| site_url: str = DEFAULT_SITE_URL,
|
| code: str = "1234",
|
| environment: str = "production",
|
| redeploy: bool = True,
|
| verify: bool = False,
|
| timeout: float = 60,
|
| ) -> dict[str, object]:
|
| worker_url = validate_worker_url(worker_url)
|
| site_url = normalize_url(site_url)
|
| commands: list[CommandResult] = []
|
|
|
| commands.append(remove_vercel_env("WORKER_BASE_URL", environment))
|
| commands.append(add_vercel_env("WORKER_BASE_URL", worker_url, environment))
|
| for key in DIRECT_CLOUD_ENV_KEYS:
|
| commands.append(remove_vercel_env(key, environment))
|
| if redeploy:
|
| commands.append(run_command([VERCEL_COMMAND, "deploy", "--prod", "--yes"]))
|
|
|
| site_checks = None
|
| if verify:
|
| site_checks = [check.__dict__ for check in verify_site(site_url, code, worker_url, timeout=timeout)]
|
|
|
| return {
|
| "workerUrl": worker_url,
|
| "siteUrl": site_url,
|
| "environment": environment,
|
| "redeployed": redeploy,
|
| "verified": verify,
|
| "commands": [
|
| {
|
| "command": result.command,
|
| "returncode": result.returncode,
|
| "stdout": result.stdout,
|
| "stderr": result.stderr,
|
| }
|
| for result in commands
|
| ],
|
| "siteChecks": site_checks,
|
| "nextCommand": (
|
| f"python scripts\\prove_live_deployment.py {worker_url} --origin {site_url} "
|
| f"--code {code} --smoke-ocr-engine arabic"
|
| ),
|
| }
|
|
|
|
|
| def main_with_args(argv: list[str] | None = None) -> int:
|
| parser = argparse.ArgumentParser(description="Set Vercel WORKER_BASE_URL, redeploy, and optionally verify the site.")
|
| parser.add_argument("worker_url", help="Public Hugging Face Space worker URL, e.g. https://user-space.hf.space")
|
| parser.add_argument("--site-url", default=DEFAULT_SITE_URL)
|
| parser.add_argument("--code", default="1234")
|
| parser.add_argument("--environment", default="production")
|
| parser.add_argument("--no-redeploy", action="store_true")
|
| parser.add_argument("--verify", action="store_true", help="Run scripts.verify_site after redeploy.")
|
| parser.add_argument("--timeout", type=float, default=60)
|
| parser.add_argument("--json", action="store_true")
|
| args = parser.parse_args(argv)
|
|
|
| result = configure_vercel_worker(
|
| args.worker_url,
|
| site_url=args.site_url,
|
| code=args.code,
|
| environment=args.environment,
|
| redeploy=not args.no_redeploy,
|
| verify=args.verify,
|
| timeout=args.timeout,
|
| )
|
| if args.json:
|
| print(json.dumps(result, indent=2))
|
| else:
|
| print(f"Configured WORKER_BASE_URL={result['workerUrl']}")
|
| if result["redeployed"]:
|
| print("Redeployed Vercel production.")
|
| print("Next:")
|
| print(result["nextCommand"])
|
| site_checks = result.get("siteChecks")
|
| if site_checks is not None and not all(check["ok"] for check in site_checks):
|
| return 1
|
| return 0
|
|
|
|
|
| def main() -> int:
|
| return main_with_args()
|
|
|
|
|
| if __name__ == "__main__":
|
| raise SystemExit(main())
|
|
|
