# streamlit_app.py — Fit Studio AI (Fashion & Apparel) v0.7.0 UI
# Dark theme; fixed-size tiles; native downloads + on-the-fly resized downloads from NATIVE (no padding).
# Backend v0.7.0 uyumlu: category-aware video prompt backend’de; frontend category/prompt/duration/aspect gönderir.
# In-memory; yerel dosya yazmaz. HF’de klasör/themes yok.
import os, io, zipfile, base64, requests, streamlit as st, uuid, tempfile, re
from pathlib import Path
from PIL import Image
# ================= Theme (no extra files) =================
try:
st._config.set_option("theme.base", "dark")
st._config.set_option("theme.primaryColor", "#ff7a1a")
st._config.set_option("theme.backgroundColor", "#0e0f12")
st._config.set_option("theme.secondaryBackgroundColor", "#171a1f")
st._config.set_option("theme.textColor", "#e6e8ea")
except Exception:
pass
# ================= Env & API =================
def _env(k): return (os.getenv(k) or "").strip().strip("'\"")
API_BASE = (
_env("FISUITE_API")
or _env("AI_LIGHTBOX_API")
or _env("LUXFIT_API")
).rstrip("/") if (
_env("FISUITE_API") or _env("AI_LIGHTBOX_API") or _env("LUXFIT_API")
) else ""
HF_TOKEN = _env("FISUITE_TOKEN") or _env("AI_LIGHTBOX_TOKEN") or _env("LUXFIT_TOKEN")
HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
# === Tile geometry (ALL preview cards same size) ===
TILE_H = int(os.getenv("TILE_H", "640")) # change via env if needed
TILE_W = max(200, int(round(TILE_H * 9 / 16))) # 16:9 default; keeps uniform layout
PREVIEW_BG = (18, 20, 24) # dark-friendly bg
GIF_MAX_W = int(os.getenv("GIF_MAX_W", "512"))
GIF_FPS = int(os.getenv("GIF_FPS", "12"))
GIF_MAX_FRAMES = GIF_FPS * 12
# ================= Session State =================
defaults = {
"results": None,
"job_counter": 0,
"duration": "6", # default duration seconds (string for API)
"rand": uuid.uuid4().hex[:8],
"exports_last": "",
}
for k, v in defaults.items():
if k not in st.session_state:
st.session_state[k] = v
# ================= Helpers =================
def _needs_auth(url: str) -> bool:
return (API_BASE and (url.startswith(API_BASE) or url.startswith("outputs/")))
@st.cache_data(ttl=300, show_spinner=False)
def fetch_bytes(url_or_path: str | None):
if not url_or_path:
return None
try:
p = Path(url_or_path)
if p.is_file():
return p.read_bytes()
url = f"{API_BASE}/{url_or_path}" if url_or_path.startswith("outputs/") else url_or_path
headers = (HEADERS if (_needs_auth(url) and HF_TOKEN) else None)
r = requests.get(url, headers=headers, timeout=180)
r.raise_for_status()
return r.content
except Exception:
return None
@st.cache_data(ttl=300, show_spinner=False)
def image_to_canvas(img_bytes: bytes, w: int = TILE_W, h: int = TILE_H, bg_rgb=PREVIEW_BG) -> bytes:
im = Image.open(io.BytesIO(img_bytes)).convert("RGBA")
iw, ih = im.size
scale = min(w / iw, h / ih)
nw, nh = max(1, int(iw*scale)), max(1, int(ih*scale))
im_resized = im.resize((nw, nh), Image.LANCZOS)
canvas = Image.new("RGBA", (w, h), (*bg_rgb, 255))
off = ((w - nw)//2, (h - nh)//2)
canvas.paste(im_resized, off, im_resized)
out = io.BytesIO(); canvas.save(out, format="PNG"); return out.getvalue()
@st.cache_data(ttl=300, show_spinner=False)
def image_size_from_bytes(b: bytes):
try:
im = Image.open(io.BytesIO(b)); return im.size
except Exception:
return None
def infer_ext(data: bytes) -> str:
try:
im = Image.open(io.BytesIO(data))
fmt = (im.format or "JPEG").lower()
return "." + {"jpeg":"jpg","jpg":"jpg","png":"png","webp":"webp"}.get(fmt, "jpg")
except Exception:
return ".jpg"
def unique_key(prefix: str) -> str:
return f"{prefix}_{st.session_state['job_counter']}_{st.session_state['rand']}_{uuid.uuid4().hex[:6]}"
def _b64(data: bytes, mime: str) -> str:
return f"data:{mime};base64," + base64.b64encode(data).decode("ascii")
# ---------- Preset parsing (accepts lowercase/uppercase x, supports A:B@L) ----------
_SIZE_RE = re.compile(r"^\s*(\d+)\s*[xX]\s*(\d+)\s*$")
_ASPECT_RE = re.compile(r"^\s*(\d+)\s*:\s*(\d+)(?:\s*@\s*(\d+))?\s*$")
def _size_from_aspect(ar_w: int, ar_h: int, long_edge: int) -> tuple[int,int]:
aw, ah, L = ar_w, ar_h, long_edge
if ah >= aw:
h = max(64, int(L)); w = max(64, int(round(h * aw / ah)))
else:
w = max(64, int(L)); h = max(64, int(round(w * ah / aw)))
return w, h
def parse_presets_for_resizing(presets_str: str) -> list[tuple[int,int,str]]:
"""
Returns list of (w, h, name).
Supports:
- '800x1200' or '800X1200'
- '9:16@1536' → computed (w,h)
"""
outs = []
if not presets_str or not isinstance(presets_str, str):
return outs
for tok in [t.strip() for t in presets_str.split(",") if t.strip()]:
m = _SIZE_RE.match(tok)
if m:
w, h = int(m.group(1)), int(m.group(2))
if w >= 64 and h >= 64:
outs.append((w, h, f"{w}x{h}"))
continue
m = _ASPECT_RE.match(tok)
if m:
aw, ah = int(m.group(1)), int(m.group(2))
L = int(m.group(3)) if m.group(3) else 1536
w, h = _size_from_aspect(aw, ah, L)
outs.append((w, h, f"{aw}:{ah}@{L}"))
continue
# dedupe by name
seen = set(); uniq = []
for w,h,name in outs:
if name not in seen:
seen.add(name); uniq.append((w,h,name))
return uniq
# ---------- Resize (no padding) = cover + center-crop to EXACT WxH ----------
@st.cache_data(show_spinner=False)
def resize_cover_exact(img_bytes: bytes, target_w: int, target_h: int, out_format: str = "JPEG") -> bytes:
im = Image.open(io.BytesIO(img_bytes)).convert("RGB")
iw, ih = im.size
scale = max(target_w / iw, target_h / ih) # cover
nw, nh = max(1, int(round(iw * scale))), max(1, int(round(ih * scale)))
im_resized = im.resize((nw, nh), Image.LANCZOS)
# center crop
left = max(0, (nw - target_w) // 2)
top = max(0, (nh - target_h) // 2)
right, bottom = left + target_w, top + target_h
cropped = im_resized.crop((left, top, right, bottom))
out = io.BytesIO()
if out_format.upper() == "PNG":
cropped.save(out, format="PNG")
elif out_format.upper() == "WEBP":
cropped.save(out, format="WEBP", quality=95, method=6)
else:
cropped.save(out, format="JPEG", quality=95, subsampling=1)
return out.getvalue()
# -------- Fixed-size IMAGE tile (uniform with video tile) --------
def show_image_tile(col, title: str, src: str|bytes|None, filename_stub="image", key_prefix=""):
col.subheader(title)
if not src:
from PIL import Image as _PIL
placeholder = _PIL.new("RGBA", (TILE_W, TILE_H), (*PREVIEW_BG, 255))
buf = io.BytesIO(); placeholder.save(buf, "PNG")
col.image(buf.getvalue(), width=TILE_W)
col.caption("—")
return None, None
b = src if isinstance(src, (bytes, bytearray)) else fetch_bytes(src)
if not b:
col.warning("Image could not be loaded")
return None, None
tile_png = image_to_canvas(b, w=TILE_W, h=TILE_H, bg_rgb=PREVIEW_BG)
col.image(tile_png, width=TILE_W)
sz = image_size_from_bytes(b)
if sz:
col.caption(f"Source: {sz[0]}×{sz[1]} px")
ext = infer_ext(b)
mime = "image/jpeg" if ext in [".jpg",".jpeg"] else ("image/png" if ext==".png" else "image/webp")
col.download_button(
"Download (full quality) — native",
data=b, # native/original bytes
file_name=f"{filename_stub}{ext}",
mime=mime,
key=unique_key(f"{key_prefix}_{filename_stub}_native_dl")
)
return src, b
# -------- Fixed-size VIDEO tile (uniform with image tile) --------
def _video_html_src(data_or_url, is_bytes: bool):
src = _b64(data_or_url, "video/mp4") if is_bytes else data_or_url
return f"""
"""
def render_video_placeholder(slot, video_url: str|None, key_prefix=""):
with slot.container():
st.subheader("Video (loop)")
if not video_url:
st.markdown(f"""
Not generated yet.
""", unsafe_allow_html=True)
return None
vb = fetch_bytes(video_url)
if vb:
st.markdown(_video_html_src(vb, is_bytes=True), unsafe_allow_html=True)
st.download_button(
"Download video (MP4)",
data=vb,
file_name="fitstudio_video.mp4",
mime="video/mp4",
key=unique_key(f"{key_prefix}_video_dl")
)
return vb
else:
st.markdown(_video_html_src(video_url, is_bytes=False), unsafe_allow_html=True)
return None
@st.cache_data(show_spinner=False)
def mp4_to_gif_bytes(mp4_bytes: bytes, target_w: int = GIF_MAX_W, fps: int = GIF_FPS, max_frames: int = GIF_MAX_FRAMES) -> bytes:
try:
import imageio.v3 as iio
from PIL import Image as _PILImage
except Exception as e:
raise RuntimeError("imageio.v3 + PIL required for GIF conversion") from e
with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as f:
f.write(mp4_bytes); mp4_path = f.name
try:
import imageio.v3 as iio2
meta = {}
try: meta = iio2.immeta(mp4_path)
except Exception: meta = {}
src_fps = meta.get("fps", fps)
step = max(1, int(round(src_fps / fps))) if isinstance(src_fps, (int, float)) and src_fps > 0 else 1
except Exception:
step = 1
frames = []
try:
for idx, frame in enumerate(iio.imiter(mp4_path)):
if idx % step != 0: continue
im = _PILImage.fromarray(frame)
if im.width > target_w:
new_h = max(1, int(im.height * target_w / im.width))
im = im.resize((target_w, new_h), Image.LANCZOS)
frames.append(im.convert("P", palette=Image.ADAPTIVE))
if len(frames) >= max_frames: break
finally:
try: Path(mp4_path).unlink(missing_ok=True)
except Exception: pass
if not frames: raise RuntimeError("No frames decoded for GIF.")
out = io.BytesIO()
frames[0].save(out, format="GIF", save_all=True, append_images=frames[1:],
loop=0, duration=max(10, int(1000 / fps)), disposal=2)
return out.getvalue()
def make_zip(named_bytes):
buf = io.BytesIO()
with zipfile.ZipFile(buf, "w", compression=zipfile.ZIP_DEFLATED) as z:
for fname, b in named_bytes:
if b: z.writestr(fname, b)
buf.seek(0); return buf.read()
def backend_ok() -> bool:
if not API_BASE: return False
try:
r = requests.get(f"{API_BASE}/health", headers=HEADERS if HF_TOKEN else None, timeout=10)
r.raise_for_status(); return True
except Exception:
return False
# --------- API calls ---------
def post_image_edit(data: dict, files_payload):
r = requests.post(f"{API_BASE}/v1/image/edit", data=data, files=files_payload or None,
headers=HEADERS if HF_TOKEN else None, timeout=600)
r.raise_for_status(); return r.json()
def post_chain(data: dict, files_payload):
payload = {**data, "to_video": "false"} # chain image step only (no video)
r = requests.post(f"{API_BASE}/v1/tryon/chain", data=payload, files=files_payload or None,
headers=HEADERS if HF_TOKEN else None, timeout=600)
r.raise_for_status(); return r.json()
def post_video(image_url: str, gender="auto", age_group="auto", frame_aspect="9:16",
duration_sec: str | None = None, category: str = "general", prompt: str | None = None):
payload = {
"image_url": image_url,
"gender": gender,
"age_group": age_group,
"frame_aspect": frame_aspect,
"category": category,
}
if duration_sec: payload["duration"] = str(duration_sec)
if prompt: payload["prompt"] = prompt
r = requests.post(f"{API_BASE}/v1/video/from-image", data=payload,
headers=HEADERS if HF_TOKEN else None, timeout=600)
r.raise_for_status(); return r.json()
def _video_prompt_override_txt(category: str) -> str:
# Backend zaten category-aware. Buraya manuel override gerekiyorsa ekle.
return ""
# ================= Page =================
st.set_page_config(page_title="Fit Suite AI — by Vahit FERYAD", layout="wide", page_icon="🧵")
left, right = st.columns([0.7, 0.3], vertical_alignment="center")
with left:
st.title("🧵 Fit Suite AI — Fashion & Apparel")
st.caption("Built by Vahit FERYAD — Demo")
with right:
badge = "🟢 Online" if backend_ok() else "🔴 Offline"
st.metric("Backend", badge)
st.write("Fast, consistent, automated fashion try-on. Virtual looks, real consistency → optional runway-style video.")
if not API_BASE:
st.error("API_BASE not set. Define env FITSTUDIO_API (or AI_LIGHTBOX_API / LUXFIT_API).")
st.stop()
# ================= Controls =================
c0, c_gender, c_age, c_aspect, c5 = st.columns([0.9, 1.0, 1.1, 1.0, 2.0])
with c0: category = st.selectbox("Category", ["general","underwear","shoes"], index=0, key="category")
with c_gender: gender = st.selectbox("Gender", ["auto","female","male","unisex"], index=0, key="gender")
with c_age: age_group= st.selectbox("Age group", ["auto","teen","young_adult","adult","mature"], index=0, key="age_group")
with c_aspect: frame_aspect = st.selectbox("Primary aspect", ["9:16","3:4","1:1","4:5","16:9"], index=0, key="frame_aspect")
with c5:
st.write("Export presets (optional)")
presets_quick = st.multiselect(
"Quick add",
[
"800x1200", "1200x800", "1500x1500",
"9:16@1536", "3:4@1536", "1:1@1500", "4:5@1600", "16:9@1536"
],
default=[], key="presets_quick"
)
presets_free = st.text_input(
"Custom (comma-separated, e.g. 800X1200, 1024x768, 4:5@1600)", value=st.session_state.get("exports_last",""), key="presets_free"
)
def _merge_presets():
toks = [t.strip() for t in (presets_free or "").split(",") if t.strip()]
toks = toks + [p for p in presets_quick if p not in toks]
s = ",".join(toks)
st.session_state["exports_last"] = s
return s
export_presets_val = _merge_presets()
c2, c3, c4 = st.columns([1.8, 1.4, 1.4])
with c2: file_list= st.file_uploader("Garment image(s)", type=["jpg","jpeg","png","webp"], accept_multiple_files=True, key="file_upl")
with c3: image_url= st.text_input("or Image URL", key="image_url")
with c4:
num_images = st.selectbox("Number of looks", [1,2,3,4], index=0, key="num_images")
custom_prompt = st.text_area("Custom prompt (blank → default)", value="", height=90, key="custom_prompt")
bA, bB = st.columns([1.0, 1.0])
with bA: st.info(f"API: {API_BASE}", icon="🔌")
with bB:
run_image = st.button("Run (Image only)", type="primary", use_container_width=True, key="run_img_btn")
run_chain = st.button("Chain (Image → prep Video)", use_container_width=True, key="run_chain_btn")
# ================= Demo preview =================
dp_in, dp_sp, dp_v = st.columns([1,1,1])
show_image_tile(dp_in, "Input Sample", fetch_bytes("input.jpg"), filename_stub="input", key_prefix="demo_in")
show_image_tile(dp_sp, "Sample Output Preview", fetch_bytes("tryon.jpg"), filename_stub="tryon", key_prefix="demo_out")
demo_vbytes = fetch_bytes("fitstudio_video.mp4")
if demo_vbytes:
dp_v.subheader("AI Generated Video Preview")
dp_v.markdown(_video_html_src(demo_vbytes, is_bytes=True), unsafe_allow_html=True)
# ================= Input preview =================
st.divider()
g1, _, _, _ = st.columns([1,1,1,1])
input_preview = None
if file_list:
try: input_preview = file_list[0].getvalue()
except Exception: input_preview = None
elif image_url:
input_preview = fetch_bytes(image_url)
show_image_tile(g1, "Input (preview)", input_preview, filename_stub="preview", key_prefix="preview")
# ================ Run helpers ================
def _build_files_payload():
files_payload = []
if file_list:
for f in file_list:
files_payload.append(("files", (f.name, f.getvalue(), f.type or "image/jpeg")))
return files_payload
def _common_form_data():
data = {
"category": st.session_state["category"],
"gender": st.session_state["gender"],
"age_group": st.session_state["age_group"],
"frame_aspect": st.session_state["frame_aspect"],
"num_images": str(st.session_state["num_images"]),
}
if st.session_state.get("custom_prompt","").strip():
data["prompt"] = st.session_state["custom_prompt"].strip()
if image_url:
data["image_urls"] = image_url.strip()
if export_presets_val:
data["export_presets"] = export_presets_val
return data
if run_image or run_chain:
if not backend_ok():
st.error("Backend not reachable. Check API_BASE / token.")
elif not (file_list or image_url):
st.error("Provide at least one garment image (upload or URL).")
else:
try:
files_payload = _build_files_payload()
form = _common_form_data()
with st.spinner("Running…"):
if run_image:
out = post_image_edit(form, files_payload)
image_json = out
else:
out = post_chain(form, files_payload) # to_video=false
image_json = out.get("image_step") or out
res_block = (image_json.get("result") or {})
imgs_primary = res_block.get("images_primary") or []
imgs_norm916 = res_block.get("images_9_16") or []
imgs_raw = res_block.get("images") or []
exports_dict = res_block.get("exports") or {}
def _collect_urls(lst):
outu = []
for it in lst:
u = it.get("url")
if u: outu.append(u)
return outu
urls_primary = _collect_urls(imgs_primary)
urls_norm = _collect_urls(imgs_norm916)
urls_raw = _collect_urls(imgs_raw)
st.session_state["job_counter"] += 1
st.session_state["results"] = {
"job_id": (image_json.get("job_id") or out.get("job_id")),
"schema_version": (image_json.get("schema_version") or out.get("schema_version")),
"image_urls_primary": urls_primary,
"image_urls_9_16": urls_norm,
"image_urls_raw": urls_raw, # NATIVE images (prefer for video & resizing)
"exports": exports_dict, # name -> list[{url,w,h}]
"video_url": None,
"frame_aspect": st.session_state["frame_aspect"],
}
except requests.HTTPError as e:
st.error(f"HTTP {e.response.status_code}: {(e.response.text or '')[:200]}")
except Exception as e:
st.error(f"Error: {e}")
# ===== Helper: dual tile (primary/9:16/native) =====
def show_dual_image_tile(col, title: str,
primary_src: str|bytes|None,
norm916_src: str|bytes|None,
native_src: str|bytes|None,
filename_stub="image", key_prefix=""):
preview_src = primary_src or norm916_src or native_src
_, preview_bytes = show_image_tile(col, title, preview_src, filename_stub=filename_stub, key_prefix=key_prefix)
def _load(src):
if isinstance(src, (bytes, bytearray)): return bytes(src)
if isinstance(src, str): return fetch_bytes(src)
return None
b_native = _load(native_src) or _load(primary_src) or _load(norm916_src) # fallbacks for preview; downloads say "native" if actually native_src
# Only keep the single "Download native" button in the base tile (already rendered inside show_image_tile for preview src).
# Now add RESIZED download buttons derived from NATIVE bytes if available.
if b_native:
# Determine output base format by native ext (prefer jpeg for photos)
ext = infer_ext(b_native).lower()
out_fmt = "JPEG" if ext in (".jpg",".jpeg",".webp",".png") else "JPEG"
# Parse presets and show buttons
presets = parse_presets_for_resizing(st.session_state.get("exports_last",""))
if presets:
st_html = "Resized downloads (no padding):
"
col.markdown(st_html, unsafe_allow_html=True)
# Show up to 4 per row
for i, (tw, th, name) in enumerate(presets):
btn_label = f"Download {name}"
try:
rb = resize_cover_exact(b_native, tw, th, out_format=out_fmt)
mime = "image/jpeg" if out_fmt.upper()=="JPEG" else ("image/png" if out_fmt.upper()=="PNG" else "image/webp")
col.download_button(
btn_label,
data=rb,
file_name=f"{filename_stub}_{name}.{ 'jpg' if out_fmt.upper()=='JPEG' else out_fmt.lower()}",
mime=mime,
key=unique_key(f"{key_prefix}_{filename_stub}_{name}_resized_dl")
)
except Exception as e:
col.caption(f"{name}: resize failed ({e})")
return preview_bytes, None, None, b_native
# --------- Source selection for VIDEO (prefer NATIVE) ---------
def _pick_source_for_video(look_idx: int, urls_primary, urls_norm, urls_raw):
if look_idx < len(urls_raw) and urls_raw[look_idx]:
return urls_raw[look_idx], "native"
if look_idx < len(urls_primary) and urls_primary[look_idx]:
return urls_primary[look_idx], "primary"
if look_idx < len(urls_norm) and urls_norm[look_idx]:
return urls_norm[look_idx], "9:16"
return None, ""
# ================ Results ================
res = st.session_state.get("results") or {}
if res:
key_prefix = f"job{st.session_state['job_counter']}"
urls_primary = res.get("image_urls_primary") or []
urls_norm916 = res.get("image_urls_9_16") or []
urls_raw = res.get("image_urls_raw") or []
exports_dict = res.get("exports") or {}
video_url = res.get("video_url")
fa = res.get("frame_aspect","9:16")
st.subheader("Results")
c1, c2, c3, c4 = st.columns([1,1,1,1])
named = []
def _triple_at(i):
primary = urls_primary[i] if i < len(urls_primary) else None
norm916 = urls_norm916[i] if i < len(urls_norm916) else None
raw = urls_raw[i] if i < len(urls_raw) else None
return primary, norm916, raw
for idx, col in enumerate([c1, c2, c3]):
p_u, n_u, r_u = _triple_at(idx)
if p_u or n_u or r_u:
title = "Look" if idx == 0 else f"Look #{idx+1}"
_, _, _, b_r = show_dual_image_tile(
col, title, p_u, n_u, r_u, filename_stub=f"look_{idx+1}", key_prefix=f"{key_prefix}_{idx}"
)
if b_r:
named.append((f"look_{idx+1}_native{infer_ext(b_r)}", b_r))
else:
show_image_tile(col, f"Look #{idx+1}", None, key_prefix=f"{key_prefix}_{idx}")
# --- Single video area with fixed size + controls ---
video_slot = c4.empty()
vbytes = render_video_placeholder(video_slot, video_url, key_prefix=key_prefix)
st.divider()
colv0, colv1, colv2, colv3 = st.columns([1.0, 1.0, 1.0, 1.0])
with colv0:
gen_video = st.checkbox("Generate video from first look", value=False, key="video_toggle")
with colv1:
keep_aspect = st.selectbox("Video aspect", ["9:16","3:4","1:1","4:5","16:9"],
index=["9:16","3:4","1:1","4:5","16:9"].index(fa))
with colv2:
duration_sec = st.number_input("Video duration (sec)", min_value=1, max_value=60,
value=int(st.session_state.get("duration","6") or 6), step=1, key="duration_num")
with colv3:
go_video = st.button("Create Video", use_container_width=True, key="video_btn")
if gen_video and go_video:
src_for_video, reason = _pick_source_for_video(0, urls_primary, urls_norm916, urls_raw)
if not src_for_video:
st.warning("No image to create video. Run image/chain first.")
else:
st.session_state["duration"] = str(int(duration_sec))
prompt_override = _video_prompt_override_txt(st.session_state.get("category",""))
with st.spinner(f"Generating video from {reason} image…"):
v = post_video(
src_for_video,
gender=st.session_state.get("gender","auto"),
age_group=st.session_state.get("age_group","auto"),
frame_aspect=keep_aspect,
duration_sec=st.session_state["duration"],
category=st.session_state.get("category","general"),
prompt=(prompt_override or None),
)
vurl = (v.get("result") or {}).get("video", {}).get("url")
if vurl:
st.session_state["results"]["video_url"] = vurl
vbytes = render_video_placeholder(video_slot, vurl, key_prefix=key_prefix)
st.info(f"Video source: {reason} • category sent: {st.session_state.get('category','general')}")
else:
st.info("Video URL not returned.")
# --- Export variants preview (from backend) — kept as-is ---
if exports_dict:
st.divider()
st.subheader("Exports")
for vname in sorted(exports_dict.keys()):
items = exports_dict.get(vname) or []
st.text(f"{vname} · {len(items)} item(s)")
cols = st.columns(4)
for i, it in enumerate(items[:8]): # show up to 8 previews, all fixed-size
u = it.get("url")
if not u: continue
_, b = show_image_tile(cols[i % 4], f"{vname} • #{i+1}", u,
filename_stub=f"{vname.replace(':','x').replace('@','_')}_{i+1}",
key_prefix=f"{key_prefix}_exp_{vname}_{i}")
if b:
named.append((f"{vname.replace(':','-').replace('@','_')}_{i+1}{infer_ext(b)}", b))
# ZIP + GIF
if named or vbytes:
if vbytes:
named.append(("video.mp4", vbytes))
zip_bytes = make_zip(named)
st.download_button(
"Download All (ZIP)",
data=zip_bytes,
file_name="fitstudio_outputs.zip",
mime="application/zip",
key=unique_key(f"{key_prefix}_zip_dl")
)
if vbytes:
try:
with st.spinner("Preparing GIF…"):
gif_bytes = mp4_to_gif_bytes(vbytes, target_w=GIF_MAX_W, fps=GIF_FPS, max_frames=GIF_MAX_FRAMES)
st.download_button(
f"Download GIF ({GIF_MAX_W}px, {GIF_FPS}fps)",
data=gif_bytes,
file_name="fitstudio_video.gif",
mime="image/gif",
key=unique_key(f"{key_prefix}_gif_dl")
)
except Exception as e:
st.info(f"GIF conversion not available: {e}. Try installing ffmpeg / imageio-ffmpeg.")
# ================= Sidebar =================
with st.sidebar:
st.caption(f"Resolved API_BASE: {API_BASE}")
st.caption("Auth header: " + ("ON" if HF_TOKEN else "OFF"))
st.divider()
if st.button("Ping /health", key=unique_key("ping_health")):
try:
r = requests.get(f"{API_BASE}/health", headers=HEADERS if HF_TOKEN else None, timeout=10)
st.write(r.status_code)
try: st.json(r.json())
except Exception: st.code((r.text or "")[:1000])
except Exception as e:
st.error(f"Health error: {e}")
if st.button("Clear cache", key=unique_key("clear_cache")):
st.cache_data.clear(); st.success("Cache cleared.")
if st.button("Clear results", key=unique_key("clear_results")):
st.session_state["results"] = None; st.success("Results cleared.")