1# /// script
2# dependencies = [
3#   "openai>=1.0",
4#   "requests",
5#   "azure-identity",
6# ]
7# ///
8"""
9deploy_model.py — Deploy fine-tuned models on Azure AI Foundry via ARM REST API.
10 
11Supports all model families with correct format/SKU mapping.
12 
13Usage:
14  python deploy_model.py --model-id "ft:gpt-4.1-mini-2025-04-14:..." --name "my-ft-eval" --capacity 100
15  python deploy_model.py --model-id "ft:gpt-oss-20b:..." --name "oss-eval" --format Microsoft --sku GlobalStandard
16  python deploy_model.py --delete --name "my-ft-eval"
17  python deploy_model.py --list
18"""
19 
20import os
21import subprocess
22import sys
23 
24try:
25    sys.stdout.reconfigure(encoding="utf-8")
26    sys.stderr.reconfigure(encoding="utf-8")
27except (AttributeError, OSError):
28    pass  # Stream not reconfigurable (older Python or non-tty); default encoding is fine
29import time
30sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
31from common import HelpOnErrorParser
32 
33import requests
34 
35 
36def _safe_error_msg(resp):
37    """Extract error message from response, handling non-JSON bodies (HTML 502/503)."""
38    try:
39        return resp.json().get("error", {}).get("message", resp.text[:200])
40    except (ValueError, KeyError):
41        return resp.text[:200] if resp.text else "Unknown error"
42 
43# Default Azure resource coordinates — override with env vars or args
44DEFAULT_SUB = os.environ.get("AZURE_SUBSCRIPTION_ID", "")
45DEFAULT_RG = os.environ.get("AZURE_RESOURCE_GROUP", "")
46DEFAULT_ACCOUNT = os.environ.get("AZURE_COGSERVICES_ACCOUNT", "")
47AZ_CLI = os.environ.get("AZ_CLI_PATH")
48if not AZ_CLI:
49    import shutil
50    AZ_CLI = shutil.which("az")
51    if not AZ_CLI:
52        # Common Windows paths
53        for candidate in [
54            r"C:\Program Files (x86)\Microsoft SDKs\Azure\CLI2\wbin\az.cmd",
55            r"C:\Program Files\Microsoft SDKs\Azure\CLI2\wbin\az.cmd",
56        ]:
57            if os.path.exists(candidate):
58                AZ_CLI = candidate
59                break
60    if not AZ_CLI:
61        AZ_CLI = "az"  # last resort, hope it's on PATH
62 
63# Model format auto-detection rules
64FORMAT_RULES = [
65    (lambda m: "oss-20b" in m.lower() or "oss20b" in m.lower(), "Microsoft", "GlobalStandard"),
66    (lambda m: "ministral" in m.lower() or "mistral" in m.lower(), "Mistral AI", "GlobalStandard"),
67    (lambda m: "llama" in m.lower() or "meta" in m.lower(), "Meta", "GlobalStandard"),
68    (lambda m: "qwen" in m.lower() or "alibaba" in m.lower(), "Alibaba", "GlobalStandard"),
69    (lambda m: True, "OpenAI", "Standard"),  # Default fallback
70]
71 
72 
73def get_arm_token():
74    """Get a fresh ARM token from Azure CLI."""
75    result = subprocess.run(
76        [AZ_CLI, "account", "get-access-token", "--query", "accessToken", "-o", "tsv"],
77        capture_output=True, text=True,
78    )
79    token = result.stdout.strip()
80    if not token:
81        raise RuntimeError(f"Failed to get ARM token: {result.stderr}")
82    return token
83 
84 
85def arm_url(sub, rg, account, deploy_name=None):
86    """Build the ARM REST API URL."""
87    base = (f"https://management.azure.com/subscriptions/{sub}"
88            f"/resourceGroups/{rg}"
89            f"/providers/Microsoft.CognitiveServices/accounts/{account}"
90            f"/deployments")
91    if deploy_name:
92        base += f"/{deploy_name}"
93    return base + "?api-version=2024-10-01"
94 
95 
96def detect_format(model_id):
97    """Auto-detect model format and SKU from model ID."""
98    for check, fmt, sku in FORMAT_RULES:
99        if check(model_id):
100            return fmt, sku
101    return "OpenAI", "Standard"
102 
103 
104def create_deployment(sub, rg, account, name, model_id, model_format, sku, capacity):
105    """Create a deployment via ARM REST API."""
106    token = get_arm_token()
107    url = arm_url(sub, rg, account, name)
108 
109    body = {
110        "sku": {"name": sku, "capacity": capacity},
111        "properties": {
112            "model": {
113                "format": model_format,
114                "name": model_id,
115                "version": "1",
116            }
117        },
118    }
119 
120    resp = requests.put(url, headers={
121        "Authorization": f"Bearer {token}",
122        "Content-Type": "application/json",
123    }, json=body, timeout=(10, 120))
124 
125    if resp.status_code in (200, 201):
126        print(f"✅ Deployment '{name}' created (format={model_format}, sku={sku}, capacity={capacity})")
127        return True
128    else:
129        print(f"❌ Deployment failed ({resp.status_code}): {_safe_error_msg(resp)}")
130        return False
131 
132 
133def wait_for_deployment(sub, rg, account, name, timeout=600, poll_interval=15):
134    """Wait for deployment to reach 'Succeeded' state."""
135    url = arm_url(sub, rg, account, name)
136    start = time.time()
137 
138    while time.time() - start < timeout:
139        token = get_arm_token()
140        try:
141            resp = requests.get(url, headers={"Authorization": f"Bearer {token}"}, timeout=(10, 60))
142        except requests.exceptions.RequestException as e:
143            print(f"  ⚠️ Polling error: {e} — retrying in {poll_interval}s")
144            time.sleep(poll_interval)
145            continue
146        if resp.status_code == 200:
147            try:
148                state = resp.json().get("properties", {}).get("provisioningState", "Unknown")
149            except (ValueError, KeyError):
150                state = "Unknown"
151            print(f"  Status: {state}")
152            if state == "Succeeded":
153                return True
154            if state in ("Failed", "Canceled"):
155                print(f"  Deployment {state}.")
156                return False
157        time.sleep(poll_interval)
158 
159    print(f"  Timed out after {timeout}s")
160    return False
161 
162 
163def delete_deployment(sub, rg, account, name):
164    """Delete a deployment."""
165    token = get_arm_token()
166    url = arm_url(sub, rg, account, name)
167    resp = requests.delete(url, headers={"Authorization": f"Bearer {token}"}, timeout=(10, 60))
168    if resp.status_code in (200, 202, 204):
169        print(f"✅ Deployment '{name}' deleted.")
170    else:
171        print(f"❌ Delete failed ({resp.status_code}): {_safe_error_msg(resp)}")
172 
173 
174def list_deployments(sub, rg, account):
175    """List all deployments."""
176    token = get_arm_token()
177    url = arm_url(sub, rg, account)
178    resp = requests.get(url, headers={"Authorization": f"Bearer {token}"}, timeout=(10, 60))
179    if resp.status_code != 200:
180        print(f"❌ Failed to list deployments ({resp.status_code}): {_safe_error_msg(resp)}")
181        return
182 
183    try:
184        deployments = resp.json().get("value", [])
185    except (ValueError, KeyError):
186        print(f"❌ Failed to parse deployment list: {resp.text[:200]}")
187        return
188    if not deployments:
189        print("No deployments found.")
190        return
191 
192    print(f"{'Name':<40} {'Model':<40} {'SKU':<15} {'State':<15}")
193    print("─" * 110)
194    for d in deployments:
195        name = d.get("name", "?")
196        model = d.get("properties", {}).get("model", {}).get("name", "?")
197        sku = d.get("sku", {}).get("name", "?")
198        state = d.get("properties", {}).get("provisioningState", "?")
199        print(f"{name:<40} {model:<40} {sku:<15} {state:<15}")
200 
201 
202def main():
203    parser = HelpOnErrorParser(description="Deploy fine-tuned models on Azure AI Foundry")
204    parser.add_argument("--sub", default=DEFAULT_SUB, help="Azure subscription ID")
205    parser.add_argument("--rg", default=DEFAULT_RG, help="Resource group")
206    parser.add_argument("--account", default=DEFAULT_ACCOUNT, help="Cognitive Services account")
207 
208    # Actions
209    parser.add_argument("--list", action="store_true", help="List all deployments")
210    parser.add_argument("--delete", action="store_true", help="Delete a deployment")
211    parser.add_argument("--wait", action="store_true", help="Wait for deployment to succeed")
212 
213    # Deployment config
214    parser.add_argument("--name", help="Deployment name (max 64 chars, alphanumeric + hyphens)")
215    parser.add_argument("--model-id", help="Fine-tuned model ID (e.g., ft:gpt-4.1-mini:...)")
216    parser.add_argument("--format", help="Model format (auto-detected if not specified)")
217    parser.add_argument("--sku", help="SKU name (auto-detected if not specified)")
218    parser.add_argument("--capacity", type=int, default=100, help="TPM capacity in thousands")
219 
220    args = parser.parse_args()
221 
222    if not all([args.sub, args.rg, args.account]):
223        print("Error: Set --sub/--rg/--account or AZURE_SUBSCRIPTION_ID/AZURE_RESOURCE_GROUP/AZURE_COGSERVICES_ACCOUNT")
224        sys.exit(1)
225 
226    if args.list:
227        list_deployments(args.sub, args.rg, args.account)
228        return
229 
230    if not args.name:
231        print("Error: --name required for create/delete/wait")
232        sys.exit(1)
233 
234    if args.delete:
235        delete_deployment(args.sub, args.rg, args.account, args.name)
236        return
237 
238    if args.wait and not args.model_id:
239        # Wait-only mode: poll an existing deployment
240        success = wait_for_deployment(args.sub, args.rg, args.account, args.name)
241        sys.exit(0 if success else 1)
242 
243    if not args.model_id:
244        print("Error: --model-id required for create")
245        sys.exit(1)
246 
247    # Auto-detect format/SKU if not specified
248    model_format = args.format
249    sku = args.sku
250    if not model_format or not sku:
251        auto_fmt, auto_sku = detect_format(args.model_id)
252        model_format = model_format or auto_fmt
253        sku = sku or auto_sku
254        print(f"Auto-detected: format={model_format}, sku={sku}")
255 
256    created = create_deployment(args.sub, args.rg, args.account, args.name,
257                      args.model_id, model_format, sku, args.capacity)
258 
259    if args.wait and created:
260        wait_for_deployment(args.sub, args.rg, args.account, args.name)
261 
262 
263if __name__ == "__main__":
264    main()
265