Refactor: Match reference version parameter passing logic

Key changes:
- web_api_bridge.py now builds profile dict directly in memory
- Pass profile to get_selected_attributes() instead of saving to file
- Remove generate_single_profile() dependency
- Use generate_final_summary() directly with profile
- Simplified flow: build profile → select attributes → generate summary
- Clear ✓/✗ indicators for user inputs vs generated fields

This matches the working reference version in experience_temp/

generate_user_profile_final/code/web_api_bridge.py

@@ -3,7 +3,7 @@
 
 """
 Web API bridge script for handling inputs from the web interface
-and generating user personas using the improved methods from generate_profile_ind.py.
+and generating user personas following the logic in generate_profile.py.
 """
 
 import json
@@ -24,7 +24,8 @@ from based_data import (
     generate_interests_and_hobbies
 )
 
-from generate_profile import generate_single_profile
+from generate_profile import generate_final_summary
+from select_attributes import get_selected_attributes, save_results
 
 
 def parse_input_data(input_file: str) -> Dict[str, Any]:
@@ -48,7 +49,7 @@ def parse_input_data(input_file: str) -> Dict[str, Any]:
 
 def generate_profile_from_input(input_data: Dict[str, Any], attribute_count: int = 200) -> Dict[str, Any]:
     """
-    Generate a complete user persona from input data using the improved generation method
+    Generate a complete user persona from input data
     
     Args:
         input_data: Input data containing basic information and optional custom values
@@ -67,117 +68,107 @@ def generate_profile_from_input(input_data: Dict[str, Any], attribute_count: int
         # Use provided basic information or generate new basic information
         age = basic_info.get('age')
         if not age:
-            print("No age provided, generating random age...")
+            print("✗ Age not provided, generating...")
             age_info = generate_age_info()
             age = age_info['age']
         else:
-            print(f"Using provided age: {age}")
+            print(f"✓ Using provided age: {age}")
         
         gender = basic_info.get('gender')
         if not gender:
-            print("No gender provided, generating random gender...")
+            print("✗ Gender not provided, generating...")
             gender = generate_gender()
         else:
-            print(f"Using provided gender: {gender}")
+            print(f"✓ Using provided gender: {gender}")
         
         occupation_info = basic_info.get('occupation', {})
         occupation = occupation_info.get('status')
         if not occupation:
-            print("No occupation provided, generating random occupation...")
+            print("✗ Occupation not provided, generating...")
             career_info = generate_career_info(age)
             occupation = career_info['status']
         else:
-            print(f"Using provided occupation: {occupation}")
+            print(f"✓ Using provided occupation: {occupation}")
         
         location_info = basic_info.get('location', {})
         if not location_info.get('city') or not location_info.get('country'):
-            print("No complete location provided, generating random location...")
+            print("✗ Location not provided, generating...")
             location_info = generate_location()
         else:
-            print(f"Using provided location: {location_info.get('city')}, {location_info.get('country')}")
+            print(f"✓ Using provided location: {location_info.get('city')}, {location_info.get('country')}")
         
         # Use custom personal values if provided, otherwise generate them
         custom_personal_values = custom_values.get('personal_values')
         if custom_personal_values and custom_personal_values.strip():
-            print("Using provided personal values...")
+            print(f"✓ Using provided personal values: {custom_personal_values[:50]}...")
             values_orientation = custom_personal_values.strip()
         else:
-            print("Generating personal values...")
+            print("✗ Personal values not provided, generating based on inputs...")
             values_dict = generate_personal_values(age, gender, occupation, location_info)
             values_orientation = values_dict.get("values_orientation", "") if isinstance(values_dict, dict) else str(values_dict)
         
         # Use custom life attitude if provided, otherwise generate it
         custom_life_attitude = custom_values.get('life_attitude')
         if custom_life_attitude and custom_life_attitude.strip():
-            print("Using provided life attitude...")
+            print(f"✓ Using provided life attitude: {custom_life_attitude[:50]}...")
             life_attitude = {
                 "outlook": custom_life_attitude.strip(),
                 "coping_mechanism": "Custom life attitude provided by user"
             }
         else:
-            print("Generating life attitude...")
+            print("✗ Life attitude not provided, generating based on inputs...")
             life_attitude = generate_life_attitude(age, gender, occupation, location_info, values_orientation)
         
         # Use custom life story if provided, otherwise generate it
         custom_life_story = custom_values.get('life_story')
         if custom_life_story and custom_life_story.strip():
-            print("Using provided life story...")
+            print(f"✓ Using provided life story: {custom_life_story[:50]}...")
             personal_story = {"personal_story": custom_life_story.strip()}
         else:
-            print("Generating personal story...")
+            print("✗ Life story not provided, generating based on inputs...")
             personal_story = generate_personal_story(age, gender, occupation, location_info, values_orientation, life_attitude)
         
         # Use custom interests/hobbies if provided, otherwise generate them
         custom_interests = custom_values.get('interests_hobbies')
         if custom_interests and custom_interests.strip():
-            print("Using provided interests and hobbies...")
+            print(f"✓ Using provided interests: {custom_interests}")
             # Split by comma and clean up
             interests_list = [i.strip() for i in custom_interests.split(',') if i.strip()]
             interests_and_hobbies = {"interests": interests_list}
         else:
-            print("Generating interests and hobbies...")
+            print("✗ Interests not provided, generating based on life story...")
             interests_and_hobbies = generate_interests_and_hobbies(personal_story)
         
-        # Build base profile structure that will be saved to user_profile.json
-        # This needs to be saved before calling generate_single_profile
-        base_profile = {
-            "age": age,
-            "gender": gender,
-            "Occupations": [occupation],
-            "location": location_info,
-            "personal_values": {
-                "values_orientation": values_orientation
+        # Build complete user persona (matching reference version structure)
+        profile = {
+            "basic_info": {
+                "age": age,
+                "gender": gender,
+                "occupation": {"status": occupation},
+                "location": location_info
             },
-            "life_attitude": life_attitude.get("outlook") if isinstance(life_attitude, dict) else str(life_attitude),
-            "personal_story": personal_story if isinstance(personal_story, dict) else {"personal_story": personal_story},
-            "interests": interests_and_hobbies
+            "values_orientation": values_orientation,
+            "life_attitude": life_attitude,
+            "personal_story": personal_story,
+            "interests_and_hobbies": interests_and_hobbies
         }
         
-        # Save the base profile to user_profile.json
-        # This is required by generate_single_profile
-        project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-        output_dir = os.path.join(project_root, "output")
-        os.makedirs(output_dir, exist_ok=True)
+        # Select attributes
+        print(f"Selecting {attribute_count} attributes...")
+        # Pass the profile directly to get_selected_attributes
+        selected_paths = get_selected_attributes(profile, attribute_count)
+        profile["selected_attributes"] = selected_paths
         
-        user_profile_path = os.path.join(output_dir, 'user_profile.json')
-        with open(user_profile_path, 'w', encoding='utf-8') as f:
-            json.dump(base_profile, f, ensure_ascii=False, indent=2)
+        # Save the selected attributes to output files
+        print("Saving selected attributes...")
+        save_results(profile, selected_paths)
         
-        print(f"Base profile saved to: {user_profile_path}")
-        
-        # Now call generate_single_profile which will:
-        # 1. Run select_attributes to choose attributes
-        # 2. Generate all sections using the improved prompts
-        # 3. Generate the final summary
-        print(f"Generating complete profile with {attribute_count} attributes...")
-        profile = generate_single_profile(template=None, profile_index=0, attribute_count=attribute_count)
-        
-        if not profile:
-            print("Failed to generate profile")
-            return {}
+        # Generate final summary
+        print("Generating final summary...")
+        summary = generate_final_summary(profile)
+        profile["Summary"] = summary
         
         return profile
-        
     except Exception as e:
         print(f"Error generating user persona: {e}")
         import traceback