Spaces:
Building
Building
File size: 10,218 Bytes
1b4f3f8 8dbff89 1b4f3f8 38415cf bf5274e 8dbff89 916c313 8dbff89 38415cf 8dbff89 38415cf bf5274e 38415cf 8dbff89 38415cf 8dbff89 38415cf 8dbff89 38415cf 8dbff89 38415cf 8dbff89 38415cf 8dbff89 bf5274e 8dbff89 bf5274e 8dbff89 38415cf 8dbff89 ec380a0 8dbff89 ec380a0 8dbff89 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 |
"""
Flare – API Executor (v2.0 · session-aware token management)
"""
from __future__ import annotations
import json, re, time, requests
from typing import Any, Dict, Optional
from utils import log
from config_provider import ConfigProvider, APIConfig
from session import Session
cfg = ConfigProvider.get()
_placeholder = re.compile(r"\{\{\s*([^\}]+?)\s*\}\}")
def _render(obj: Any, session: Session, api_name: str) -> Any:
"""Render template with session variables and tokens"""
def replacer(match):
key = match.group(1)
if key.startswith("variables."):
var_name = key.split(".", 1)[1]
return str(session.variables.get(var_name, ""))
if key.startswith("auth_tokens."):
parts = key.split(".")
if len(parts) >= 3:
token_api = parts[1]
token_field = parts[2]
token_data = session.auth_tokens.get(token_api, {})
return str(token_data.get(token_field, ""))
if key.startswith("config."):
attr_name = key.split(".", 1)[1]
return str(getattr(cfg.global_config, attr_name, ""))
return match.group(0)
if isinstance(obj, str):
return _placeholder.sub(replacer, obj)
if isinstance(obj, dict):
return {k: _render(v, session, api_name) for k, v in obj.items()}
if isinstance(obj, list):
return [_render(v, session, api_name) for v in obj]
return obj
def _fetch_token(api: APIConfig, session: Session) -> None:
"""Fetch new auth token"""
if not api.auth or not api.auth.enabled:
return
log(f"🔑 Fetching token for {api.name}")
try:
body = _render(api.auth.token_request_body, session, api.name)
headers = {"Content-Type": "application/json"}
response = requests.post(
str(api.auth.token_endpoint),
json=body,
headers=headers,
timeout=api.timeout_seconds
)
response.raise_for_status()
json_data = response.json()
# Extract token using path
token = json_data
for path_part in api.auth.response_token_path.split("."):
token = token.get(path_part)
if token is None:
raise ValueError(f"Token path {api.auth.response_token_path} not found in response")
# Store in session
session.auth_tokens[api.name] = {
"token": token,
"expiry": time.time() + 3500, # ~1 hour
"refresh_token": json_data.get("refresh_token")
}
log(f"✅ Token obtained for {api.name}")
except Exception as e:
log(f"❌ Token fetch failed for {api.name}: {e}")
raise
def _refresh_token(api: APIConfig, session: Session) -> bool:
"""Refresh existing token"""
if not api.auth or not api.auth.token_refresh_endpoint:
return False
token_info = session.auth_tokens.get(api.name, {})
if not token_info.get("refresh_token"):
return False
log(f"🔄 Refreshing token for {api.name}")
try:
body = _render(api.auth.token_refresh_body or {}, session, api.name)
body["refresh_token"] = token_info["refresh_token"]
response = requests.post(
str(api.auth.token_refresh_endpoint),
json=body,
timeout=api.timeout_seconds
)
response.raise_for_status()
json_data = response.json()
# Extract new token
token = json_data
for path_part in api.auth.response_token_path.split("."):
token = token.get(path_part)
if token is None:
raise ValueError(f"Token path {api.auth.response_token_path} not found in refresh response")
# Update session
session.auth_tokens[api.name] = {
"token": token,
"expiry": time.time() + 3500,
"refresh_token": json_data.get("refresh_token", token_info["refresh_token"])
}
log(f"✅ Token refreshed for {api.name}")
return True
except Exception as e:
log(f"❌ Token refresh failed for {api.name}: {e}")
return False
def _ensure_token(api: APIConfig, session: Session) -> None:
"""Ensure valid token exists for API"""
if not api.auth or not api.auth.enabled:
return
token_info = session.auth_tokens.get(api.name)
# No token yet
if not token_info:
_fetch_token(api, session)
return
# Token still valid
if token_info.get("expiry", 0) > time.time():
return
# Try refresh first
if _refresh_token(api, session):
return
# Refresh failed, get new token
_fetch_token(api, session)
def call_api(api: APIConfig, session: Session) -> requests.Response:
"""Execute API call with automatic token management"""
# Ensure valid token
_ensure_token(api, session)
# Prepare request
headers = _render(api.headers, session, api.name)
body = _render(api.body_template, session, api.name)
# Handle proxy
proxies = None
if api.proxy:
if isinstance(api.proxy, str):
proxies = {"http": api.proxy, "https": api.proxy}
elif hasattr(api.proxy, "enabled") and api.proxy.enabled:
proxy_url = str(api.proxy.url)
proxies = {"http": proxy_url, "https": proxy_url}
# Prepare request parameters
request_params = {
"method": api.method,
"url": str(api.url),
"headers": headers,
"timeout": api.timeout_seconds
}
# Add body based on method
if api.method in ("POST", "PUT", "PATCH"):
request_params["json"] = body
elif api.method == "GET" and body:
request_params["params"] = body
if proxies:
request_params["proxies"] = proxies
# Execute with retry
retry_count = api.retry.retry_count if api.retry else 0
last_error = None
response = None
for attempt in range(retry_count + 1):
try:
log(f"🌐 API call: {api.name} {api.method} {api.url} (attempt {attempt + 1}/{retry_count + 1})")
response = requests.request(**request_params)
# Handle 401 Unauthorized
if response.status_code == 401 and api.auth and api.auth.enabled and attempt < retry_count:
log(f"🔒 Got 401, refreshing token for {api.name}")
_fetch_token(api, session) # Force new token
headers = _render(api.headers, session, api.name) # Re-render headers
request_params["headers"] = headers
continue
response.raise_for_status()
log(f"✅ API call successful: {api.name} ({response.status_code})")
# Response mapping işlemi - başarılı her response için
if response.status_code in (200, 201, 202, 204) and hasattr(api, 'response_mappings') and api.response_mappings:
try:
# 204 No Content durumunda JSON parse etmeye çalışma
if response.status_code != 204 and response.content:
response_json = response.json()
for mapping in api.response_mappings:
var_name = mapping.get('variable_name')
var_type = mapping.get('type', 'str')
json_path = mapping.get('json_path')
if not all([var_name, json_path]):
continue
# JSON path'ten değeri al
value = response_json
for path_part in json_path.split('.'):
if isinstance(value, dict):
value = value.get(path_part)
if value is None:
break
if value is not None:
# Type conversion
if var_type == 'int':
value = int(value)
elif var_type == 'float':
value = float(value)
elif var_type == 'bool':
value = bool(value)
elif var_type == 'date':
# ISO format'ta sakla
value = str(value)
else: # str
value = str(value)
# Session'a kaydet
session.variables[var_name] = value
log(f"📝 Mapped response value: {var_name} = {value}")
except Exception as e:
log(f"⚠️ Response mapping error: {e}")
return response
except requests.exceptions.Timeout as e:
last_error = e
log(f"⏱️ API timeout for {api.name} (attempt {attempt + 1})")
except requests.exceptions.RequestException as e:
last_error = e
log(f"❌ API error for {api.name}: {e}")
# Retry backoff
if attempt < retry_count:
backoff = api.retry.backoff_seconds if api.retry else 2
if api.retry and api.retry.strategy == "exponential":
backoff = backoff * (2 ** attempt)
log(f"⏳ Waiting {backoff}s before retry...")
time.sleep(backoff)
# All retries failed
if last_error:
raise last_error
raise requests.exceptions.RequestException(f"API call failed after {retry_count + 1} attempts") |