Update app.py

app.py

@@ -17,7 +17,7 @@ import time
 import traceback
 import uuid
 from collections import defaultdict
-from datetime import date
+from datetime import date, datetime, timezone
 
 import gradio as gr
 import requests
@@ -30,8 +30,11 @@ BASE = os.environ.get(
     "https://studio.syncmonster.ai/neuralgarage/saas/api/v1/clients",
 ).rstrip("/")
 HEADERS = {"x-api-key": API_KEY}
-MAX_SECONDS = float(os.environ.get("MAX_SECONDS", 10))
-PER_USER_DAILY = int(os.environ.get("PER_USER_DAILY", 3))
+MAX_SECONDS = float(os.environ.get("MAX_SECONDS", 15))
+PER_USER_DAILY = int(os.environ.get("PER_USER_DAILY", 5))
+MAX_UPLOAD_SECONDS = float(os.environ.get("MAX_UPLOAD_SECONDS", 600))  # longest upload we'll trim from
+LEADS_DATASET = os.environ.get("LEADS_DATASET", "").strip()  # e.g. trydrama/demo-users (private dataset)
+HF_TOKEN = os.environ.get("HF_TOKEN", "").strip()            # Space *secret* with write access
 GLOBAL_DAILY = int(os.environ.get("GLOBAL_DAILY", 200))
 ADMIN_USERS = {u.strip().lower() for u in os.environ.get("ADMIN_USERS", "").split(",") if u.strip()}
 FLOW = os.environ.get("FLOW", "oneshot").strip().lower()  # "oneshot" (default) or "twostep"
@@ -292,12 +295,15 @@ def video_seconds(path):
                         f"ffprobe: {short(out.stderr, 300)}")
 
 
-def normalize_video(src, workdir):
+def normalize_video(src, workdir, start=0.0, length=None):
     """Re-encode any upload (HEVC/ProRes .mov etc.) to H.264 + AAC MP4,
-    which browsers can preview and the API can read. Keeps the audio track."""
+    which browsers can preview and the API can read. Keeps the audio track.
+    With start/length, cuts that part of the clip at the same time."""
     out = os.path.join(workdir, "input_h264.mp4")
+    cut = (["-ss", f"{start:.2f}"] if start > 0 else [])
+    limit = (["-t", f"{length:.2f}"] if length else [])
     result = subprocess.run(
-        ["ffmpeg", "-y", "-i", src,
+        ["ffmpeg", "-y", *cut, "-i", src, *limit,
          "-map", "0:v:0", "-map", "0:a:0?",
          "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
          "-c:v", "libx264", "-preset", "veryfast", "-crf", "18",
@@ -348,20 +354,47 @@ def watermark(src, workdir, run):
     return out
 
 
+def clock(seconds):
+    seconds = int(round(seconds))
+    return f"{seconds // 60}:{seconds % 60:02d}"
+
+
+def trim_note(start, total):
+    end = min(start + MAX_SECONDS, total)
+    return (f'<div class="dr-trim-note">Your clip is <b>{clock(total)}</b> long. The demo uses '
+            f'{int(MAX_SECONDS)} seconds: <b>{clock(start)} to {clock(end)}</b>. '
+            f'Drag the slider to choose a different part.</div>')
+
+
+NO_TRIM = (gr.update(visible=False), gr.update(value=0), "")
+
+
 def prepare_upload(video):
-    """Runs right after upload so the preview plays and the API gets a clean file."""
+    """Runs right after upload so the preview plays and the API gets a clean file.
+    Clips longer than MAX_SECONDS get cut to their first MAX_SECONDS, and the trim
+    panel appears so the person can pick a different part.
+    Returns (video_in, original_path_state, trim_panel, trim_slider, trim_note)."""
     if not video:
-        return None
+        return None, None, *NO_TRIM
     try:
         before = probe(video)
         seconds = video_seconds(video)
-        if seconds > MAX_SECONDS + 0.5:
-            log.info(f"[upload] rejected (too long, {seconds:.1f}s): {before}")
-            raise DemoError("TOO_LONG", f"Please use a clip of {int(MAX_SECONDS)} seconds or less.")
-        out = normalize_video(video, tempfile.mkdtemp())
         log.info(f"[upload] original: {before}")
-        log.info(f"[upload] converted: {probe(out)}")
-        return out
+        if seconds > MAX_UPLOAD_SECONDS:
+            raise DemoError("TOO_LONG", f"This video is over {int(MAX_UPLOAD_SECONDS // 60)} minutes. "
+                                        "Upload a shorter clip; the demo uses up to "
+                                        f"{int(MAX_SECONDS)} seconds of it.")
+        if seconds <= MAX_SECONDS + 0.5:
+            out = normalize_video(video, tempfile.mkdtemp())
+            log.info(f"[upload] converted: {probe(out)}")
+            return out, None, *NO_TRIM
+        out = normalize_video(video, tempfile.mkdtemp(), 0.0, MAX_SECONDS)
+        latest = max(0.0, seconds - MAX_SECONDS)
+        log.info(f"[upload] long clip ({seconds:.1f}s), trimmed to 0-{MAX_SECONDS:g}s: {probe(out)}")
+        return (out, video,
+                gr.update(visible=True),
+                gr.update(minimum=0, maximum=round(latest, 1), value=0, step=0.5),
+                trim_note(0, seconds))
     except DemoError as e:
         raise gr.Error(e.user_message, print_exception=False)
     except Exception:
@@ -369,6 +402,81 @@ def prepare_upload(video):
         raise gr.Error("Couldn't process this upload. Try another file.", print_exception=False)
 
 
+def retrim(original, start):
+    """Cuts a new MAX_SECONDS window from the original upload when the slider moves."""
+    if not original or not os.path.exists(original):
+        raise gr.Error("Upload the video again to choose a different part.", print_exception=False)
+    try:
+        total = video_seconds(original)
+        start = max(0.0, min(float(start or 0), total - MAX_SECONDS))
+        out = normalize_video(original, tempfile.mkdtemp(), start, MAX_SECONDS)
+        log.info(f"[trim] {start:.1f}-{start + MAX_SECONDS:.1f}s of {total:.1f}s")
+        return out, trim_note(start, total)
+    except DemoError as e:
+        raise gr.Error(e.user_message, print_exception=False)
+    except Exception:
+        log.error(f"[trim] unexpected error:\n{traceback.format_exc()}")
+        raise gr.Error("Couldn't cut this part of the video. Try another position.", print_exception=False)
+
+
+# ---------- user log (who tried the demo) ----------
+# One JSON line per event, pushed every 10 minutes to a private dataset repo.
+# Off unless LEADS_DATASET and HF_TOKEN are set. Never blocks or breaks the demo.
+
+_leads = None
+_leads_file = None
+_seen_today = set()
+
+if LEADS_DATASET and HF_TOKEN:
+    try:
+        from huggingface_hub import CommitScheduler, create_repo
+        create_repo(LEADS_DATASET, repo_type="dataset", private=True, exist_ok=True, token=HF_TOKEN)
+        _leads_dir = os.path.join(tempfile.gettempdir(), "drama_users")
+        os.makedirs(_leads_dir, exist_ok=True)
+        _leads_file = os.path.join(_leads_dir, f"events-{uuid.uuid4().hex[:8]}.jsonl")
+        _leads = CommitScheduler(repo_id=LEADS_DATASET, repo_type="dataset", folder_path=_leads_dir,
+                                 path_in_repo="data", every=10, private=True, token=HF_TOKEN)
+        log.info(f"[users] logging sign-ins and runs to dataset {LEADS_DATASET}")
+    except Exception as e:
+        _leads = None
+        log.warning(f"[users] user log is off: {type(e).__name__}: {e}")
+
+
+def track(event, profile, **extra):
+    if _leads is None or profile is None:
+        return
+    try:
+        orgs = profile.get("orgs") or []
+        row = {
+            "time": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+            "event": event,
+            "username": profile.username,
+            "name": profile.name,
+            "email": profile.get("email"),
+            "email_verified": profile.get("email_verified"),
+            "profile_url": profile.profile,
+            "avatar": profile.picture,
+            "orgs": [o.get("preferred_username") or o.get("name") for o in orgs if isinstance(o, dict)],
+            "admin": is_admin(profile.username),
+            **extra,
+        }
+        with _leads.lock:
+            with open(_leads_file, "a") as f:
+                f.write(json.dumps(row, default=str) + "\n")
+    except Exception as e:
+        log.warning(f"[users] couldn't record {event}: {type(e).__name__}: {e}")
+
+
+def on_visit(profile: gr.OAuthProfile | None):
+    """Records signed-in visitors once a day, including ones who never press the button."""
+    if profile is None:
+        return
+    key = (profile.username, date.today().isoformat())
+    if key not in _seen_today:
+        _seen_today.add(key)
+        track("visit", profile)
+
+
 # ---------- usage limits ----------
 
 _usage = defaultdict(int)
@@ -571,7 +679,7 @@ def settings_chips(drama):
 
 # ---------- main handler ----------
 
-def run(video, mood, excited, angry, profile: gr.OAuthProfile | None):
+def run(video, mood, excited, angry, updates, profile: gr.OAuthProfile | None):
     def stop(message):
         raise gr.Error(message, print_exception=False)
 
@@ -588,6 +696,7 @@ def run(video, mood, excited, angry, profile: gr.OAuthProfile | None):
     ctx = Run(profile.username)
     ctx.log(f"new run: user={ctx.user} admin={is_admin(ctx.user)} drama={drama} flow={FLOW}")
     counted = False
+    clip = {"drama": drama, "marketing_opt_in": bool(updates)}
     try:
         take_quota(ctx.user)
         counted = True
@@ -595,13 +704,15 @@ def run(video, mood, excited, angry, profile: gr.OAuthProfile | None):
         ctx.stage = "prepare"
         yield None, status_html("working", "Preparing your clip…", 1)
         if video_seconds(video) > MAX_SECONDS + 0.5:
-            raise DemoError("TOO_LONG", f"Please use a clip of {int(MAX_SECONDS)} seconds or less.")
+            raise DemoError("TOO_LONG", f"Please use a clip of {int(MAX_SECONDS)} seconds or less. "
+                                        "Upload it again and pick a part with the slider.")
         workdir = tempfile.mkdtemp()
         if not os.path.basename(video).startswith("input_h264"):
             video = normalize_video(video, workdir)  # sample clips skip the upload step
         audio, audio_source = extract_audio(video, workdir)
         v, a = probe(video), probe(audio)
         ctx.facts["video"] = f"{v.get('video')} {v.get('duration_s')}s {v.get('size_kb')}KB"
+        clip["clip_seconds"] = v.get("duration_s")
         ctx.facts["audio"] = f"{a.get('audio')} {a.get('duration_s')}s ({audio_source})"
         ctx.log(f"video: {v}")
         ctx.log(f"audio: {a} ({audio_source})")
@@ -628,6 +739,7 @@ def run(video, mood, excited, angry, profile: gr.OAuthProfile | None):
         ctx.stage = "watermark"
         result = watermark(raw, workdir, ctx)
         report(ctx, "SUCCESS")
+        track("run", profile, outcome="success", run_id=ctx.id, seconds=round(time.time() - ctx.started), **clip)
         yield result, status_html("done", f"Done in {ctx.elapsed()}", 5,
                                   settings_chips(drama))
 
@@ -636,8 +748,10 @@ def run(video, mood, excited, angry, profile: gr.OAuthProfile | None):
             refund_quota(ctx.user)
         if e.category == "LIMIT":
             ctx.log(f"blocked by usage limit: {e.user_message}")
+            track("limit_hit", profile, run_id=ctx.id, **clip)
         else:
             report(ctx, "FAILED", e.category, e.detail)
+            track("run", profile, outcome="failed", error=e.category, run_id=ctx.id, **clip)
         yield None, status_html("error", e.user_message, note=f"Reference: {ctx.id}")
         stop(f"{e.user_message} (ref: {ctx.id})")
     except gr.Error:
@@ -647,6 +761,7 @@ def run(video, mood, excited, angry, profile: gr.OAuthProfile | None):
             refund_quota(ctx.user)
         ctx.log(f"UNEXPECTED {type(e).__name__}: {e}\n{traceback.format_exc()}", logging.ERROR)
         report(ctx, "FAILED", "UNEXPECTED", f"{type(e).__name__}: {e}")
+        track("run", profile, outcome="failed", error="UNEXPECTED", run_id=ctx.id, **clip)
         yield None, status_html("error", "Something unexpected went wrong.", note=f"Reference: {ctx.id}")
         stop(f"Something unexpected went wrong. (ref: {ctx.id})")
 
@@ -881,6 +996,13 @@ CSS = """
 #dr-go { height: 50px; font-size: 16px !important; font-weight: 600 !important; border-radius: 10px !important;
   box-shadow: none !important; transition: background .15s ease; }
 .gradio-container .dr-fine { font-size: 12px !important; color: var(--dr-faint) !important; text-align: center !important; margin: 0 !important; }
+.gradio-container .dr-fine a { color: var(--dr-faint) !important; text-decoration: underline !important; padding: 0 !important; margin: 0 !important; display: inline !important; }
+.gradio-container .dr-trim { border: 1px solid var(--dr-line) !important; border-radius: 10px !important; padding: 12px 14px !important; gap: 6px !important; }
+.gradio-container .dr-trim-note { font-size: 13px !important; color: var(--dr-muted) !important; line-height: 1.5 !important; }
+.gradio-container .dr-trim-note b { color: var(--dr-text) !important; font-weight: 600 !important; }
+.gradio-container #dr-optin { margin: 2px 0 !important; }
+.gradio-container #dr-trim-start .tab-like-container { display: none !important; }
+.gradio-container #dr-optin label span { font-size: 13px !important; color: var(--dr-muted) !important; }
 
 /* status */
 .gradio-container .dr-status { border-radius: 10px; padding: 14px 16px; border: 1px solid var(--dr-line); background: #0e0e11; }
@@ -1021,8 +1143,14 @@ with gr.Blocks(title=PAGE_TITLE) as demo:
     with gr.Row(elem_id="dr-main", equal_height=True):
         with gr.Column(scale=1, elem_classes="dr-card"):
             gr.HTML('<div class="dr-label"><b>01</b>Upload a clip</div>'
-                    '<div class="dr-hint">One person, face clearly visible, front-on. .mp4 or .mov.</div>')
+                    '<div class="dr-hint">One person, face clearly visible, front-on. .mp4 or .mov. '
+                    f'Longer than {int(MAX_SECONDS)} seconds? You can pick which part to use.</div>')
             video_in = gr.Video(show_label=False, sources=["upload"], height=320, elem_classes="dr-media")
+            original = gr.State(None)
+            with gr.Column(visible=False, elem_classes="dr-trim") as trim_box:
+                trim_info = gr.HTML()
+                trim_start = gr.Slider(0, 1, value=0, step=0.5, label="Choose the part to use",
+                                       buttons=[], elem_id="dr-trim-start")
             samples = [[p] for p in sorted(glob.glob("examples/*.mp4"))]
             if samples:
                 gr.Examples(samples, inputs=[video_in], label="No clip handy? Try one of these")
@@ -1036,9 +1164,12 @@ with gr.Blocks(title=PAGE_TITLE) as demo:
                                  info="−1 very sad · 0 neutral · +1 big smile")
                 excited = gr.Slider(0, 1, value=d_exc, step=0.05, label="Excitement")
                 angry = gr.Slider(0, 1, value=d_ang, step=0.05, label="Anger")
+            updates = gr.Checkbox(label="Email me DRAMA product updates and offers", value=False,
+                                  container=False, elem_id="dr-optin")
             go = gr.Button("Change expression", variant="primary", elem_id="dr-go")
             gr.HTML('<div class="dr-fine">Only upload footage you have the right to use. '
-                    'Demo results are watermarked.</div>')
+                    'Demo results are watermarked. We keep a record of who uses the demo; see our '
+                    '<a href="https://trydrama.io/privacypolicy/" target="_blank">Privacy Policy</a>.</div>')
 
         with gr.Column(scale=1, elem_classes="dr-card"):
             gr.HTML('<div class="dr-label"><b>03</b>Your result</div>'
@@ -1099,11 +1230,16 @@ with gr.Blocks(title=PAGE_TITLE) as demo:
     for slider in (mood, excited, angry):
         slider.release(lambda: "Custom", outputs=[preset],
                        api_visibility="private", show_progress="hidden")
-    video_in.upload(prepare_upload, inputs=[video_in], outputs=[video_in], api_visibility="private")
-    video_in.clear(lambda: (None, IDLE), outputs=[video_out, status_out], api_visibility="private")
+    video_in.upload(prepare_upload, inputs=[video_in],
+                    outputs=[video_in, original, trim_box, trim_start, trim_info], api_visibility="private")
+    trim_start.release(retrim, inputs=[original, trim_start], outputs=[video_in, trim_info],
+                       api_visibility="private")
+    video_in.clear(lambda: (None, IDLE, None, gr.update(visible=False)),
+                   outputs=[video_out, status_out, original, trim_box], api_visibility="private")
+    demo.load(on_visit, inputs=None, outputs=None, api_visibility="private", show_progress="hidden")
     go.click(
         run,
-        inputs=[video_in, mood, excited, angry],
+        inputs=[video_in, mood, excited, angry, updates],
         outputs=[video_out, status_out],
         concurrency_limit=2,
         api_visibility="private",