Update app.py

app.py

@@ -283,52 +283,145 @@ def _ensure_min_events(sequence, event_check_func, min_proportion, generator_fun
         return current_sequence, False
     else: return current_sequence, True
 
-# Attention Sequence Generator (Unchanged from v8.1)
+# --- Modified Attention Sequence Generator (v8.2 - FIX SyntaxError) ---
 def generate_attention_sequence(params):
-    n = params['trials']; cue = params['cue']; target = params['target']
-    similar_distractors = params['similar_distractors']; other_distractors = ATTN_OTHER_DISTRACTORS
-    p_ax = params['prob_A_then_X']; p_ao = params['prob_A_then_Other']
-    p_x = params['prob_X_alone']; p_s = params['prob_Similar_alone']; p_o = params['prob_Other_distractor']
+    n = params['trials']
+    cue = params['cue']
+    target = params['target']
+    similar_distractors = params['similar_distractors']
+    other_distractors = ATTN_OTHER_DISTRACTORS
+
+    # Get probabilities from params (calculated in get_difficulty_params)
+    p_ax = params['prob_A_then_X']
+    p_ao = params['prob_A_then_Other'] # Note: A->Other can include Similar or Other distractors
+    p_x = params['prob_X_alone']
+    p_s = params['prob_Similar_alone']
+    p_o = params['prob_Other_distractor']
+
+    # Normalize just in case they don't perfectly sum to 1 due to floating point
     total_p = p_ax + p_ao + p_x + p_s + p_o
     if abs(total_p - 1.0) > 1e-6:
-        if total_p > 1e-9: p_ax /= total_p; p_ao /= total_p; p_x /= total_p; p_s /= total_p; p_o /= total_p
-    final_sequence = []
+        # print(f"WARN: Attention probabilities sum to {total_p:.4f}, normalizing.")
+        if total_p > 1e-9:
+            p_ax /= total_p; p_ao /= total_p; p_x /= total_p; p_s /= total_p; p_o /= total_p
+
+    final_sequence = [] # Define upfront for access within _generate_single_pass
+
     def _generate_single_pass():
-        nonlocal final_sequence; sq = []; last_stim = None
+        nonlocal final_sequence # Allow modification
+        sq = []
+        last_stim = None
         for i in range(n):
-            chosen_stim = None; r = random.random(); cdf = 0.0
+            chosen_stim = None
+            # Core logic based on probabilities of specific conditions happening *at this trial*
+            r = random.random()
+            cdf = 0.0
+
             if r < (cdf := cdf + p_ax):
-                if last_stim != cue:
-                    if cue != last_stim: sq.append(cue); last_stim = cue
-                    else: chosen_stim = target; \
-                          if random.random() < p_s / (p_s + p_x + p_o + 1e-9): chosen_stim = random.choice(similar_distractors); \
-                          elif random.random() < p_o / (p_o + p_x + 1e-9): chosen_stim = random.choice(other_distractors)
-                if chosen_stim is None: chosen_stim = target
+                # Force an A->X pair if possible, otherwise just X
+                if last_stim != cue: # Need to insert A first
+                    # Check if inserting A makes sense (not A->A)
+                    if cue != last_stim:
+                        sq.append(cue)
+                        last_stim = cue
+                    else: # Cannot insert A (would be A->A), so choose X, S, or O based on their probabilities
+                        # --- START FIX for SyntaxError ---
+                        chosen_stim = None
+                        prob_pool_xso = p_x + p_s + p_o # Probabilities for X_alone, S_alone, O_distractor
+                        if prob_pool_xso < 1e-9:
+                            chosen_stim = target # Fallback if all probs are near zero
+                        else:
+                            rand_choice = random.random() * prob_pool_xso # Random value scaled to the pool sum
+                            if rand_choice < p_x:
+                                chosen_stim = target
+                            elif rand_choice < p_x + p_s:
+                                chosen_stim = random.choice(similar_distractors)
+                            else: # Implicitly rand_choice < p_x + p_s + p_o
+                                chosen_stim = random.choice(other_distractors)
+                        # --- END FIX for SyntaxError ---
+
+                if chosen_stim is None: # We added 'A' or it was already 'A'
+                    chosen_stim = target
             elif r < (cdf := cdf + p_ao):
+                # Force an A -> Other pair (can be Similar or Other)
                 distractor_after_a = random.choice(similar_distractors + other_distractors)
                 if last_stim != cue:
-                    if cue != last_stim: sq.append(cue); last_stim = cue
-                    else: pool = [target] + similar_distractors + other_distractors; chosen_stim = random.choice([s for s in pool if s != last_stim]); \
-                          if not chosen_stim: chosen_stim = random.choice(pool)
-                if chosen_stim is None: chosen_stim = distractor_after_a; \
-                    if chosen_stim == cue: pool = [target] + similar_distractors + other_distractors; chosen_stim = random.choice([s for s in pool if s != cue]); \
-                           if not chosen_stim: chosen_stim = random.choice(pool)
-            elif r < (cdf := cdf + p_x): chosen_stim = target
-            elif r < (cdf := cdf + p_s): chosen_stim = random.choice(similar_distractors)
-            else: chosen_stim = random.choice(other_distractors)
-            if chosen_stim == last_stim and chosen_stim not in [cue, target]: pool = similar_distractors + other_distractors; available = [d for d in pool if d != last_stim]; chosen_stim = random.choice(available) if available else chosen_stim
-            if len(sq) < n: sq.append(chosen_stim); last_stim = chosen_stim
-        final_sequence = sq[:n]; return final_sequence
-    def check_ax_pairs(seq, index, item): return index > 0 and item == target and seq[index - 1] == cue
-    def check_similar_alone(seq, index, item): return item in similar_distractors and (index == 0 or seq[index - 1] != cue)
+                    if cue != last_stim:
+                        sq.append(cue)
+                        last_stim = cue
+                    else: # Cannot insert A, choose a different non-A stimulus
+                         pool = [target] + similar_distractors + other_distractors
+                         chosen_stim = random.choice([s for s in pool if s != last_stim])
+                         if not chosen_stim: chosen_stim = random.choice(pool) # Fallback
+
+                if chosen_stim is None:
+                    chosen_stim = distractor_after_a
+                    # Avoid A -> A
+                    if chosen_stim == cue:
+                       pool = [target] + similar_distractors + other_distractors
+                       chosen_stim = random.choice([s for s in pool if s != cue])
+                       if not chosen_stim: chosen_stim = random.choice(pool) # Fallback
+            elif r < (cdf := cdf + p_x):
+                chosen_stim = target
+            elif r < (cdf := cdf + p_s):
+                chosen_stim = random.choice(similar_distractors)
+            else: # (implicitly r < cdf + p_o)
+                chosen_stim = random.choice(other_distractors)
+
+            # Final checks to avoid immediate repeats of non-cue/non-target
+            if chosen_stim == last_stim and chosen_stim not in [cue, target]:
+                 pool = similar_distractors + other_distractors
+                 available = [d for d in pool if d != last_stim]
+                 chosen_stim = random.choice(available) if available else chosen_stim # Keep if no alternative
+
+            # If we inserted 'A', we might need to adjust sequence length
+            if len(sq) < n:
+                sq.append(chosen_stim)
+                last_stim = chosen_stim
+
+        # Trim if we added extra 'A's making it too long
+        final_sequence = sq[:n]
+        return final_sequence # Return for the helper function
+
+    # Define check functions for _ensure_min_events
+    def check_ax_pairs(seq, index, item):
+        # Is item at index 'target' and preceded by 'cue'?
+        return index > 0 and item == target and seq[index - 1] == cue
+
+    def check_similar_alone(seq, index, item):
+        # Is item a similar distractor and NOT preceded by 'cue'?
+        return item in similar_distractors and (index == 0 or seq[index - 1] != cue)
+
+    # Generate initial sequence
     generated_sequence = _generate_single_pass()
-    sequence_ax_ok, success_ax = _ensure_min_events(generated_sequence, check_ax_pairs, ATTN_MIN_PAIR_PROPORTION if p_ax > 0 else 0, _generate_single_pass)
-    if not success_ax: print(f"WARN: Failed to ensure minimum A->X pairs ({ATTN_MIN_PAIR_PROPORTION*100:.1f}%).")
-    final_sequence, success_sa = _ensure_min_events(sequence_ax_ok, check_similar_alone, ATTN_MIN_SIMILAR_ALONE_PROPORTION if p_s > 0 else 0, _generate_single_pass)
-    if not success_sa: print(f"WARN: Failed to ensure minimum Similar Alone pairs ({ATTN_MIN_SIMILAR_ALONE_PROPORTION*100:.1f}%).")
+
+    # Ensure minimum A->X pairs
+    sequence_ax_ok, success_ax = _ensure_min_events(
+        generated_sequence,
+        check_ax_pairs,
+        ATTN_MIN_PAIR_PROPORTION if p_ax > 0 else 0,
+        _generate_single_pass # Regeneration function
+    )
+    if not success_ax:
+        print(f"WARN: Failed to ensure minimum A->X pairs ({ATTN_MIN_PAIR_PROPORTION*100:.1f}%).")
+
+    # Ensure minimum Similar Alone trials *using the potentially regenerated sequence*
+    final_sequence, success_sa = _ensure_min_events(
+        sequence_ax_ok, # Start with the sequence that passed (or failed) the A->X check
+        check_similar_alone,
+        ATTN_MIN_SIMILAR_ALONE_PROPORTION if p_s > 0 else 0,
+        _generate_single_pass # Regeneration function (might undo A->X guarantee, but necessary)
+    )
+    if not success_sa:
+         print(f"WARN: Failed to ensure minimum Similar Alone pairs ({ATTN_MIN_SIMILAR_ALONE_PROPORTION*100:.1f}%).")
+
+    # Final check (optional): Re-verify A->X count after ensuring Similar Alone, as regeneration might affect it
     final_ax_count = sum(1 for i, item in enumerate(final_sequence) if check_ax_pairs(final_sequence, i, item))
     min_ax_needed = int(n * ATTN_MIN_PAIR_PROPORTION) if p_ax > 0 else 0
-    if final_ax_count < min_ax_needed: print(f"WARN: Final Attn sequence low on A->X pairs ({final_ax_count}/{min_ax_needed}) after S-Alone check.")
+    if final_ax_count < min_ax_needed:
+        print(f"WARN: Final Attn sequence low on A->X pairs ({final_ax_count}/{min_ax_needed}) after S-Alone check.")
+
+    # Expected response info remains simple, logic is in process_response
     ex = {'target': target, 'cue': cue, 'similar_distractor_key': params['similar_distractor_key']}
     return final_sequence, ex