VALENTINERONTEZ.

1def generate_variants(words, transcript_text, video_path,
2    *, fps=FPS, target_count=8, on_token=None):
3    """Two parallel editorial strategies with
4    Jaccard similarity fallback for diversity."""
5.
6    candidates = generate_candidates(words)
7    scored = extract_features(candidates, transcript_text,
8        on_token=on_token)
9.
10    strategies = ["hook_first", "story_first"]
11    variants = []
12    hook_selected_ids = set()
13.
14    for strategy in strategies:
15        scored_copy = deep_copy_segments(scored)
16        compute_scores(scored_copy, strategy)
17.
18        avoid = hook_selected_ids if strategy == "story_first" else None
19        selected = select_top_moments(
20            scored_copy, target_count=target_count,
21            diversity_weight=0.3, strategy=strategy,
22            avoid_ids=avoid,
23        )
24.
25        if strategy == "hook_first":
26            hook_selected_ids = {s.segment_id for s in selected}
27        if strategy == "story_first" and hook_selected_ids:
28            _enforce_uniqueness_quota(
29                selected, scored_copy, hook_selected_ids)
30.
31        timeline, scores = assemble_variant(
32            selected, video_path, strategy, fps)
33        variants.append(build_result(strategy, timeline, scores))
34.
35    # Low-diversity fallback: Jaccard > 0.8 triggers reselect
36    set_a = {m.segment_id for m in variants[0].selected_moments}
37    set_b = {m.segment_id for m in variants[1].selected_moments}
38    if jaccard_similarity(set_a, set_b) > 0.8:
39        variants[1] = _reselect_story_first(
40            scored, variants[0], hook_selected_ids,
41            video_path, fps, target_count, diversity_weight=0.7)
42.
43    return variants

1# Lua script for atomic lock release (compare-and-swap)
2_RELEASE_LOCK_SCRIPT = """
3if redis.call("get", KEYS[1]) == ARGV[1] then
4    return redis.call("del", KEYS[1])
5else
6    return 0
7end
8"""
9.
10async def acquire_lock(redis, edit_session_id, timeout=30):
11    """Distributed lock via Redis SET NX EX."""
12    key = f"arlu:edit_lock:{edit_session_id}"
13    token = secrets.token_hex(16)
14    acquired = await redis.set(key, token, nx=True, ex=timeout)
15    return token if acquired else None
16.
17async def release_lock(redis, edit_session_id, token):
18    """Release only if token matches (atomic Lua eval)."""
19    key = f"arlu:edit_lock:{edit_session_id}"
20    return bool(await redis.eval(
21        _RELEASE_LOCK_SCRIPT, 1, key, token))
22.
23class EditHistory:
24    """Undo/redo stack with variant lifecycle tracking."""
25.
26    def push(self, new_state, previous_variant_id=None):
27        if self.current is not None:
28            self.past.append(self.current)
29            self.past_variant_ids.append(previous_variant_id)
30            if len(self.past) > MAX_HISTORY:
31                self.past = self.past[-MAX_HISTORY:]
32        self.current = new_state
33        self.future.clear()
34.
35    def undo(self):
36        if not self.past: return None, None
37        self.future.append(self.current)
38        vid = self.past_variant_ids.pop()
39        self.future_variant_ids.append(vid)
40        self.current = self.past.pop()
41        return self.current, vid