Update app.py

app.py

@@ -51,18 +51,14 @@ class JobStatus(str, Enum):
     COMPLETED = "completed"
     FAILED = "failed"
 
-# Enhanced Story scene model with character consistency
+# Simple Story scene model
 class StoryScene(BaseModel):
     visual: str
     text: str
-    characters_present: List[str] = []  # Which characters are in this scene
-    scene_type: str = "general"  # "action", "dialogue", "establishing", etc.
 
 class CharacterDescription(BaseModel):
     name: str
     description: str
-    visual_prompt: str = ""  # Detailed visual description for AI
-    key_features: List[str] = []  # Critical features that must stay consistent
 
 class StorybookRequest(BaseModel):
     story_title: str
@@ -71,7 +67,7 @@ class StorybookRequest(BaseModel):
     model_choice: str = "dreamshaper-8"
     style: str = "childrens_book"
     callback_url: Optional[str] = None
-    consistency_seed: Optional[int] = None  # For consistent character generation
+    consistency_seed: Optional[int] = None
 
 class JobStatusResponse(BaseModel):
     job_id: str
@@ -91,22 +87,6 @@ MODEL_CHOICES = {
     "sd-2.1": "stabilityai/stable-diffusion-2-1",
 }
 
-# FALLBACK CHARACTER TEMPLATES (used only if n8n doesn't provide character details)
-FALLBACK_CHARACTER_TEMPLATES = {
-    "Sparkle the Star Cat": {
-        "visual_prompt": "small white kitten with distinctive silver star-shaped spots on fur, big golden eyes, shiny blue collar with star charm, playful expression",
-        "key_features": ["star-shaped spots", "blue collar", "golden eyes", "white fur"],
-    },
-    "Benny the Bunny": {
-        "visual_prompt": "fluffy brown rabbit with long ears, bright green eyes, red scarf around neck, cheerful expression",
-        "key_features": ["red scarf", "long ears", "green eyes", "brown fur"],
-    },
-    "Tilly the Turtle": {
-        "visual_prompt": "gentle green turtle with shiny turquoise shell decorated with swirl patterns, wise expression, slow-moving",
-        "key_features": ["turquoise shell", "swirl patterns", "green skin", "wise expression"],
-    }
-}
-
 # GLOBAL STORAGE
 job_storage = {}
 model_cache = {}
@@ -159,138 +139,9 @@ print("🚀 Initializing Storybook Generator API...")
 load_model("dreamshaper-8")
 print("✅ Model loaded and ready!")
 
-# DYNAMIC CHARACTER PROCESSING FUNCTIONS
-def process_character_descriptions(characters_from_request):
-    """Process character descriptions from n8n and create consistency templates"""
-    character_templates = {}
-    
-    for character in characters_from_request:
-        char_name = character.name
-        
-        # Use provided visual_prompt or generate from description
-        if character.visual_prompt:
-            visual_prompt = character.visual_prompt
-        else:
-            # Generate visual prompt from description
-            visual_prompt = generate_visual_prompt_from_description(character.description, char_name)
-        
-        # Use provided key_features or extract from description
-        if character.key_features:
-            key_features = character.key_features
-        else:
-            key_features = extract_key_features_from_description(character.description)
-        
-        character_templates[char_name] = {
-            "visual_prompt": visual_prompt,
-            "key_features": key_features,
-            "consistency_keywords": f"consistent character, same {char_name.split()[-1].lower()}, maintaining appearance",
-            "source": "n8n_request"  # Track where this template came from
-        }
-    
-    print(f"✅ Processed {len(character_templates)} characters from n8n request")
-    return character_templates
-
-def generate_visual_prompt_from_description(description, character_name):
-    """Generate a visual prompt from character description"""
-    # Basic extraction of visual elements
-    description_lower = description.lower()
-    
-    # Extract species/type
-    species_keywords = ["kitten", "cat", "rabbit", "bunny", "turtle", "dog", "bird", "dragon", "bear", "fox"]
-    species = "character"
-    for keyword in species_keywords:
-        if keyword in description_lower:
-            species = keyword
-            break
-    
-    # Extract colors
-    color_keywords = ["white", "black", "brown", "red", "blue", "green", "yellow", "golden", "silver", "orange"]
-    colors = []
-    for color in color_keywords:
-        if color in description_lower:
-            colors.append(color)
-    
-    # Extract distinctive features
-    feature_keywords = ["spots", "stripes", "collar", "scarf", "shell", "wings", "horn", "tail", "ears", "eyes"]
-    features = []
-    for feature in feature_keywords:
-        if feature in description_lower:
-            features.append(feature)
-    
-    # Build visual prompt
-    visual_prompt_parts = []
-    if colors:
-        visual_prompt_parts.append(f"{' '.join(colors)} {species}")
-    else:
-        visual_prompt_parts.append(species)
-    
-    visual_prompt_parts.append(character_name)
-    
-    if features:
-        visual_prompt_parts.append(f"with {', '.join(features)}")
-    
-    # Add emotional/character traits
-    trait_keywords = ["playful", "brave", "curious", "kind", "cheerful", "wise", "calm", "friendly"]
-    traits = [trait for trait in trait_keywords if trait in description_lower]
-    if traits:
-        visual_prompt_parts.append(f"{', '.join(traits)} expression")
-    
-    visual_prompt = " ".join(visual_prompt_parts)
-    print(f"🔧 Generated visual prompt for {character_name}: {visual_prompt}")
-    
-    return visual_prompt
-
-def extract_key_features_from_description(description):
-    """Extract key features from character description"""
-    description_lower = description.lower()
-    key_features = []
-    
-    # Look for distinctive physical features
-    feature_patterns = [
-        r"(\w+)\s+(?:spots|stripes|marks)",
-        r"(\w+)\s+(?:collar|scarf|ribbon)",
-        r"(\w+)\s+(?:eyes|fur|skin|shell)",
-        r"(\w+)\s+(?:ears|tail|wings|horn)"
-    ]
-    
-    for pattern in feature_patterns:
-        matches = re.findall(pattern, description_lower)
-        key_features.extend(matches)
-    
-    # Remove duplicates and limit to 3 most important features
-    key_features = list(set(key_features))[:3]
-    
-    # If no features found, use some defaults based on character type
-    if not key_features:
-        if any(word in description_lower for word in ["kitten", "cat"]):
-            key_features = ["whiskers", "tail", "paws"]
-        elif any(word in description_lower for word in ["rabbit", "bunny"]):
-            key_features = ["long ears", "fluffy tail", "paws"]
-        elif any(word in description_lower for word in ["turtle"]):
-            key_features = ["shell", "slow moving", "wise eyes"]
-        else:
-            key_features = ["distinctive appearance", "consistent features"]
-    
-    print(f"🔧 Extracted key features: {key_features}")
-    return key_features
-
-# ENHANCED PROMPT ENGINEERING WITH DYNAMIC CHARACTER CONSISTENCY
-def enhance_prompt_with_characters(scene_visual, characters_present, character_templates, style="childrens_book", scene_number=1):
-    """Create prompts that maintain character consistency using dynamic templates"""
-    
-    # Get character descriptions for this scene
-    character_descriptions = []
-    consistency_keywords = []
-    
-    for char_name in characters_present:
-        if char_name in character_templates:
-            char_data = character_templates[char_name]
-            character_descriptions.append(f"{char_name}: {char_data['visual_prompt']}")
-            consistency_keywords.append(char_data['consistency_keywords'])
-        else:
-            # Fallback if character not in templates
-            character_descriptions.append(f"{char_name}: distinctive character")
-            consistency_keywords.append(f"consistent {char_name}")
+# SIMPLE PROMPT ENGINEERING - USE PURE PROMPTS ONLY
+def enhance_prompt_simple(scene_visual, style="childrens_book"):
+    """Simple prompt enhancement - uses only the provided visual prompt with style"""
     
     # Style templates
     style_templates = {
@@ -302,82 +153,28 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
     
     style_prompt = style_templates.get(style, style_templates["childrens_book"])
     
-    # Build the enhanced prompt
-    character_context = ". ".join(character_descriptions)
-    consistency_context = ", ".join(consistency_keywords)
+    # Use only the provided visual prompt with style
+    enhanced_prompt = f"{style_prompt}, {scene_visual}"
     
-    enhanced_prompt = (
-        f"{style_prompt}, {scene_visual}. "
-        f"Featuring: {character_context}. "
-        f"Maintain character consistency: {consistency_context}. "
-        f"Scene {scene_number} of storybook series. "
-    )
-    
-    # Quality boosters for consistency
-    quality_boosters = [
-        "consistent character design", "maintain identical features", 
-        "same characters throughout", "continuous visual narrative",
-        "professional storybook illustration", "cohesive art style",
-        "character continuity", "consistent proportions"
-    ]
-    
-    enhanced_prompt += ", ".join(quality_boosters)
-    
-    # Enhanced negative prompt to avoid inconsistencies
+    # Basic negative prompt for quality
     negative_prompt = (
-        "inconsistent characters, different appearances, changing features, "
-        "multiple versions of same character, inconsistent art style, "
         "blurry, low quality, bad anatomy, deformed characters, "
-        "wrong proportions, mismatched features, different art style"
+        "wrong proportions, mismatched features"
     )
     
     return enhanced_prompt, negative_prompt
 
-def extract_characters_from_visual(visual_description, available_characters):
-    """Extract character names from visual description using available characters"""
-    characters = []
-    visual_lower = visual_description.lower()
-    
-    # Check for each available character name in the visual description
-    for char_name in available_characters:
-        # Use the first word or main identifier from character name
-        char_identifier = char_name.split()[0].lower()
-        if char_identifier in visual_lower or char_name.lower() in visual_lower:
-            characters.append(char_name)
+def generate_image_simple(prompt, model_choice, style, scene_number, consistency_seed=None):
+    """Generate image using pure prompts only"""
     
-    return characters
-
-def generate_character_reference_sheet(characters):
-    """Generate reference descriptions for consistent character generation"""
-    reference_sheet = {}
+    # Enhance prompt with simple style addition
+    enhanced_prompt, negative_prompt = enhance_prompt_simple(prompt, style)
     
-    for character in characters:
-        char_name = character.name
-        reference_sheet[char_name] = {
-            "name": char_name,
-            "base_prompt": character.visual_prompt if character.visual_prompt else generate_visual_prompt_from_description(character.description, char_name),
-            "key_features": character.key_features if character.key_features else extract_key_features_from_description(character.description),
-            "must_include": character.key_features[:2] if character.key_features else []
-        }
-    
-    return reference_sheet
-
-def generate_consistent_image(prompt, model_choice, style, characters_present, character_templates, scene_number, consistency_seed=None):
-    """Generate image with character consistency measures using dynamic templates"""
-    
-    # Enhance prompt with character consistency
-    enhanced_prompt, negative_prompt = enhance_prompt_with_characters(
-        prompt, characters_present, character_templates, style, scene_number
-    )
-    
-    # Use a consistent seed for character generation
+    # Use seed if provided
     if consistency_seed:
-        base_seed = consistency_seed
+        scene_seed = consistency_seed + scene_number
     else:
-        base_seed = hash("".join(characters_present)) % 1000000 if characters_present else random.randint(1000, 9999)
-    
-    # Adjust seed slightly per scene but maintain character consistency
-    scene_seed = base_seed + scene_number
+        scene_seed = random.randint(1000, 9999)
     
     try:
         pipe = load_model(model_choice)
@@ -385,32 +182,23 @@ def generate_consistent_image(prompt, model_choice, style, characters_present, c
         image = pipe(
             prompt=enhanced_prompt,
             negative_prompt=negative_prompt,
-            num_inference_steps=35,  # Increased for better quality
-            guidance_scale=7.5,      # Slightly lower for more consistency
+            num_inference_steps=35,
+            guidance_scale=7.5,
             width=768,
-            height=768,
+            height=1024,  # Portrait for better full-body
             generator=torch.Generator(device="cpu").manual_seed(scene_seed)
         ).images[0]
         
-        print(f"✅ Generated consistent image for scene {scene_number}")
-        print(f"👥 Characters: {characters_present}")
+        print(f"✅ Generated image for scene {scene_number}")
         print(f"🌱 Seed used: {scene_seed}")
+        print(f"📝 Pure prompt used: {prompt}")
         
         return image
         
     except Exception as e:
-        print(f"❌ Consistent generation failed: {str(e)}")
+        print(f"❌ Generation failed: {str(e)}")
         raise
 
-# Backward compatibility functions
-def enhance_prompt(prompt, style="childrens_book"):
-    """Legacy function for backward compatibility"""
-    return enhance_prompt_with_characters(prompt, [], {}, style, 1)
-
-def generate_high_quality_image(prompt, model_choice="dreamshaper-8", style="childrens_book", negative_prompt=""):
-    """Legacy function for backward compatibility"""
-    return generate_consistent_image(prompt, model_choice, style, [], {}, 1)
-
 # LOCAL FILE MANAGEMENT FUNCTIONS
 def save_image_to_local(image, prompt, style="test"):
     """Save image to local persistent storage"""
@@ -516,13 +304,13 @@ def save_to_oci_bucket(image, text_content, story_title, page_number, file_type=
             'subfolder': f'stories/{story_title}'
         }
         
-        # Create session with retry strategy - FIXED PARAMETERS
+        # Create session with retry strategy
         session = requests.Session()
         retry_strategy = Retry(
-            total=3,  # Retry 3 times
-            status_forcelist=[429, 500, 502, 503, 504],  # Retry on these status codes
-            allowed_methods=["POST"],  # CORRECTED: Use 'allowed_methods' instead of 'method_whitelist'
-            backoff_factor=1  # Wait 1, 2, 4 seconds between retries
+            total=3,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["POST"],
+            backoff_factor=1
         )
         adapter = HTTPAdapter(max_retries=retry_strategy)
         session.mount("http://", adapter)
@@ -566,15 +354,10 @@ def test_oci_connection():
         print(f"🔧 Connection test failed: {e}")
         return False
 
-
 # JOB MANAGEMENT FUNCTIONS
 def create_job(story_request: StorybookRequest) -> str:
     job_id = str(uuid.uuid4())
     
-    # Process character descriptions from n8n
-    character_templates = process_character_descriptions(story_request.characters)
-    character_references = generate_character_reference_sheet(story_request.characters)
-    
     job_storage[job_id] = {
         "status": JobStatus.PENDING,
         "progress": 0,
@@ -583,13 +366,11 @@ def create_job(story_request: StorybookRequest) -> str:
         "result": None,
         "created_at": time.time(),
         "updated_at": time.time(),
-        "pages": [],
-        "character_templates": character_templates,
-        "character_references": character_references
+        "pages": []
     }
     
     print(f"📝 Created job {job_id} for story: {story_request.story_title}")
-    print(f"👥 Processed {len(character_templates)} characters from n8n request")
+    print(f"📄 Scenes to generate: {len(story_request.scenes)}")
     
     return job_id
 
@@ -615,7 +396,7 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
         try:
             callback_url = request_data["callback_url"]
             
-            # Enhanced callback data
+            # Simple callback data
             callback_data = {
                 "job_id": job_id,
                 "status": status.value,
@@ -623,10 +404,8 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
                 "message": message,
                 "story_title": request_data["story_title"],
                 "total_scenes": len(request_data["scenes"]),
-                "total_characters": len(request_data["characters"]),
                 "timestamp": time.time(),
-                "source": "huggingface-storybook-generator",
-                "estimated_time_remaining": calculate_remaining_time(job_id, progress)
+                "source": "huggingface-storybook-generator"
             }
             
             # Add result data for completed jobs
@@ -635,23 +414,9 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
                     "total_pages": result.get("total_pages", 0),
                     "generation_time": result.get("generation_time", 0),
                     "oci_bucket_url": result.get("oci_bucket_url", ""),
-                    "pages_generated": result.get("generated_pages", 0),
-                    "characters_used": result.get("characters_used", 0)
+                    "pages_generated": result.get("generated_pages", 0)
                 }
             
-            # Add current scene info for processing jobs
-            if status == JobStatus.PROCESSING:
-                current_scene = progress // (100 // len(request_data["scenes"])) + 1
-                callback_data["current_scene"] = current_scene
-                callback_data["total_scenes"] = len(request_data["scenes"])
-                if current_scene <= len(request_data["scenes"]):
-                    scene_visual = request_data["scenes"][current_scene-1]["visual"]
-                    callback_data["scene_description"] = scene_visual[:100] + "..."
-                    
-                    # Add characters in current scene
-                    if "characters_present" in request_data["scenes"][current_scene-1]:
-                        callback_data["characters_in_scene"] = request_data["scenes"][current_scene-1]["characters_present"]
-            
             headers = {
                 'Content-Type': 'application/json',
                 'User-Agent': 'Storybook-Generator/1.0'
@@ -688,26 +453,27 @@ def calculate_remaining_time(job_id, progress):
     
     return "Unknown"
 
-# ENHANCED BACKGROUND TASK WITH DYNAMIC CHARACTER CONSISTENCY
+# SIMPLE BACKGROUND TASK - USES PURE PROMPTS ONLY
 def generate_storybook_background(job_id: str):
-    """Background task to generate complete storybook with dynamic character consistency"""
+    """Background task to generate complete storybook using pure prompts only"""
     try:
+        # Test OCI connection first
+        print("🔧 Testing OCI API connection...")
+        oci_connected = test_oci_connection()
+        if not oci_connected:
+            print("⚠️ OCI API connection test failed - will use local fallback")
+        
         job_data = job_storage[job_id]
         story_request_data = job_data["request"]
         story_request = StorybookRequest(**story_request_data)
-        character_templates = job_data["character_templates"]
         
-        print(f"🎬 Starting DYNAMIC storybook generation for job {job_id}")
+        print(f"🎬 Starting storybook generation for job {job_id}")
         print(f"📖 Story: {story_request.story_title}")
-        print(f"👥 Characters: {len(story_request.characters)} (from n8n)")
         print(f"📄 Scenes: {len(story_request.scenes)}")
+        print(f"🎨 Style: {story_request.style}")
         print(f"🌱 Consistency seed: {story_request.consistency_seed}")
         
-        # Log character details
-        for char in story_request.characters:
-            print(f"   - {char.name}: {char.description[:50]}...")
-        
-        update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting storybook generation with dynamic character consistency...")
+        update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting storybook generation with pure prompts...")
         
         total_scenes = len(story_request.scenes)
         generated_pages = []
@@ -716,37 +482,27 @@ def generate_storybook_background(job_id: str):
         for i, scene in enumerate(story_request.scenes):
             progress = 5 + int((i / total_scenes) * 90)
             
-            # Extract characters for this scene
-            characters_present = []
-            if hasattr(scene, 'characters_present') and scene.characters_present:
-                characters_present = scene.characters_present
-            else:
-                # Fallback: extract from visual description using available characters
-                available_chars = [char.name for char in story_request.characters]
-                characters_present = extract_characters_from_visual(scene.visual, available_chars)
-            
             update_job_status(
                 job_id, 
                 JobStatus.PROCESSING, 
                 progress, 
-                f"Generating page {i+1}/{total_scenes} with {len(characters_present)} characters: {scene.visual[:50]}..."
+                f"Generating page {i+1}/{total_scenes}: {scene.visual[:50]}..."
             )
             
             try:
-                print(f"🖼️ Generating page {i+1} with characters: {characters_present}")
+                print(f"🖼️ Generating page {i+1}")
+                print(f"📝 Pure prompt: {scene.visual}")
                 
-                # Generate consistent image using dynamic character templates
-                image = generate_consistent_image(
+                # Generate image using pure prompt only
+                image = generate_image_simple(
                     scene.visual, 
                     story_request.model_choice, 
                     story_request.style,
-                    characters_present,
-                    character_templates,
                     i + 1,
                     story_request.consistency_seed
                 )
                 
-                # ADD LOCAL FALLBACK SAVE
+                # Save locally as backup
                 local_filepath, local_filename = save_image_to_local(image, scene.visual, story_request.style)
                 print(f"💾 Image saved locally as backup: {local_filename}")
                 
@@ -776,13 +532,12 @@ def generate_storybook_background(job_id: str):
                         "text_url": text_url,
                         "text_content": scene.text,
                         "visual_description": scene.visual,
-                        "characters_present": characters_present,
-                        "prompt_used": f"Dynamic consistent generation with {len(characters_present)} characters",
-                        "local_backup_path": local_filepath  # Store local path as backup
+                        "prompt_used": scene.visual,  # Store the pure prompt
+                        "local_backup_path": local_filepath
                     }
                     generated_pages.append(page_data)
                     
-                    print(f"✅ Page {i+1} completed - Characters: {characters_present}")
+                    print(f"✅ Page {i+1} completed")
                     
                 except Exception as upload_error:
                     # If OCI upload fails, use local file as fallback
@@ -791,12 +546,11 @@ def generate_storybook_background(job_id: str):
                     
                     page_data = {
                         "page_number": i + 1,
-                        "image_url": f"local://{local_filepath}",  # Mark as local file
+                        "image_url": f"local://{local_filepath}",
                         "text_url": f"local://text_content_{i+1}",
                         "text_content": scene.text,
                         "visual_description": scene.visual,
-                        "characters_present": characters_present,
-                        "prompt_used": f"Dynamic consistent generation with {len(characters_present)} characters",
+                        "prompt_used": scene.visual,
                         "local_backup_path": local_filepath,
                         "upload_error": str(upload_error)
                     }
@@ -821,13 +575,11 @@ def generate_storybook_background(job_id: str):
         result = {
             "story_title": story_request.story_title,
             "total_pages": total_scenes,
-            "characters_used": len(story_request.characters),
             "generated_pages": len(generated_pages),
             "generation_time": round(generation_time, 2),
             "folder_path": f"stories/{story_request.story_title}",
             "oci_bucket_url": f"https://oci.com/stories/{story_request.story_title}",
             "consistency_seed": story_request.consistency_seed,
-            "character_names": [char.name for char in story_request.characters],
             "pages": generated_pages,
             "file_structure": {
                 "images": [f"page_{i+1:03d}.png" for i in range(total_scenes)],
@@ -840,7 +592,7 @@ def generate_storybook_background(job_id: str):
             }
         }
         
-        status_message = f"🎉 Storybook completed! {len(generated_pages)} pages with {len(story_request.characters)} dynamic characters created in {generation_time:.2f}s."
+        status_message = f"🎉 Storybook completed! {len(generated_pages)} pages created in {generation_time:.2f}s using pure prompts."
         if local_fallback_count > 0:
             status_message += f" {local_fallback_count} pages saved locally due to OCI upload issues."
         
@@ -852,19 +604,19 @@ def generate_storybook_background(job_id: str):
             result
         )
         
-        print(f"🎉 DYNAMIC Storybook generation finished for job {job_id}")
+        print(f"🎉 Storybook generation finished for job {job_id}")
         print(f"📁 OCI Uploads: {oci_success_count} successful, {local_fallback_count} local fallbacks")
-        print(f"👥 Dynamic character consistency maintained for {len(story_request.characters)} characters across {total_scenes} scenes")
+        print(f"📝 All prompts used exactly as provided from Telegram")
         
     except Exception as e:
-        error_msg = f"Dynamic story generation failed: {str(e)}"
+        error_msg = f"Story generation failed: {str(e)}"
         print(f"❌ {error_msg}")
         update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
 
 # FASTAPI ENDPOINTS (for n8n)
 @app.post("/api/generate-storybook")
 async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
-    """Main endpoint for n8n integration - generates complete storybook with dynamic character consistency"""
+    """Main endpoint for n8n integration - generates complete storybook using pure prompts"""
     try:
         print(f"📥 Received n8n request for story: {request.get('story_title', 'Unknown')}")
         
@@ -873,15 +625,6 @@ async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
             request['consistency_seed'] = random.randint(1000, 9999)
             print(f"🌱 Generated consistency seed: {request['consistency_seed']}")
         
-        # Ensure characters have required fields
-        if 'characters' in request:
-            for char in request['characters']:
-                if 'visual_prompt' not in char or not char['visual_prompt']:
-                    # Generate visual prompt from description if not provided
-                    char['visual_prompt'] = ""
-                if 'key_features' not in char:
-                    char['key_features'] = []
-        
         # Convert to Pydantic model
         story_request = StorybookRequest(**request)
         
@@ -892,25 +635,23 @@ async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
         # Create job immediately
         job_id = create_job(story_request)
         
-        # Start background processing (runs independently of HF idle)
+        # Start background processing
         background_tasks.add_task(generate_storybook_background, job_id)
         
         # Immediate response for n8n
         response_data = {
             "status": "success",
-            "message": "Storybook generation with dynamic character consistency started successfully",
+            "message": "Storybook generation with pure prompts started successfully",
             "job_id": job_id,
             "story_title": story_request.story_title,
             "total_scenes": len(story_request.scenes),
-            "total_characters": len(story_request.characters),
-            "character_names": [char.name for char in story_request.characters],
             "consistency_seed": story_request.consistency_seed,
             "callback_url": story_request.callback_url,
             "estimated_time_seconds": len(story_request.scenes) * 35,
             "timestamp": datetime.now().isoformat()
         }
         
-        print(f"✅ Job {job_id} started with dynamic character consistency for: {story_request.story_title}")
+        print(f"✅ Job {job_id} started with pure prompts for: {story_request.story_title}")
         
         return response_data
         
@@ -945,7 +686,6 @@ async def api_health():
         "timestamp": datetime.now().isoformat(),
         "active_jobs": len(job_storage),
         "models_loaded": list(model_cache.keys()),
-        "fallback_templates": list(FALLBACK_CHARACTER_TEMPLATES.keys()),
         "oci_api_connected": OCI_API_BASE_URL
     }
 
@@ -965,89 +705,31 @@ async def delete_local_image_api(filename: str):
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
-# MISSING HELPER FUNCTIONS FOR GRADIO INTERFACE
-def delete_current_image(filepath):
-    """Delete the currently displayed image"""
-    if not filepath:
-        return "❌ No image to delete", None, None, refresh_local_images()
-    
-    success, message = delete_local_image(filepath)
-    updated_files = refresh_local_images()
-    
-    if success:
-        status_msg = f"✅ {message}"
-        return status_msg, None, "Image deleted successfully!", updated_files
-    else:
-        return f"❌ {message}", None, "Delete failed", updated_files
-
-def clear_all_images():
-    """Delete all local images"""
-    try:
-        storage_info = get_local_storage_info()
-        deleted_count = 0
-        
-        if "images" in storage_info:
-            for image_info in storage_info["images"]:
-                success, _ = delete_local_image(image_info["path"])
-                if success:
-                    deleted_count += 1
-        
-        updated_files = refresh_local_images()
-        return f"✅ Deleted {deleted_count} images", updated_files
-    except Exception as e:
-        return f"❌ Error: {str(e)}", refresh_local_images()
-
-# Enhanced Gradio interface with dynamic character testing
+# SIMPLE GRADIO INTERFACE
 def create_gradio_interface():
-    """Create Gradio interface with dynamic character consistency features"""
+    """Create simple Gradio interface for testing"""
     
-    def generate_test_image_with_characters(prompt, model_choice, style_choice, character_names_text):
-        """Generate a single image for testing character consistency"""
+    def generate_test_image_simple(prompt, model_choice, style_choice):
+        """Generate a single image using pure prompt only"""
         try:
             if not prompt.strip():
                 return None, "❌ Please enter a prompt", None
             
-            # Parse character names from text input
-            character_names = [name.strip() for name in character_names_text.split(",") if name.strip()]
-            
-            print(f"🎨 Generating test image with prompt: {prompt}")
-            print(f"👥 Character names: {character_names}")
-            
-            # Create dynamic character templates for testing
-            character_templates = {}
-            for char_name in character_names:
-                character_templates[char_name] = {
-                    "visual_prompt": f"{char_name}, distinctive appearance, consistent features",
-                    "key_features": ["consistent appearance", "maintain features"],
-                    "consistency_keywords": f"consistent {char_name}"
-                }
-            
-            # Enhance the prompt with character consistency
-            enhanced_prompt, negative_prompt = enhance_prompt_with_characters(
-                prompt, character_names, character_templates, style_choice, 1
-            )
+            print(f"🎨 Generating test image with pure prompt: {prompt}")
             
-            # Generate the image
-            image = generate_consistent_image(
+            # Generate the image using pure prompt
+            image = generate_image_simple(
                 prompt, 
                 model_choice, 
                 style_choice,
-                character_names,
-                character_templates,
                 1
             )
             
             # Save to local storage
             filepath, filename = save_image_to_local(image, prompt, style_choice)
             
-            character_info = f"👥 Characters: {', '.join(character_names)}" if character_names else "👥 No specific characters"
-            
             status_msg = f"""✅ Success! Generated: {prompt}
 
-{character_info}
-
-🎨 Enhanced prompt: {enhanced_prompt[:200]}...
-
 📁 **Local file:** {filename if filename else 'Not saved'}"""
             
             return image, status_msg, filepath
@@ -1057,9 +739,9 @@ def create_gradio_interface():
             print(error_msg)
             return None, error_msg, None
     
-    with gr.Blocks(title="Premium Children's Book Illustrator with Dynamic Character Consistency", theme="soft") as demo:
-        gr.Markdown("# 🎨 Premium Children's Book Illustrator")
-        gr.Markdown("Generate **studio-quality** storybook images with **dynamic character consistency**")
+    with gr.Blocks(title="Simple Image Generator", theme="soft") as demo:
+        gr.Markdown("# 🎨 Simple Image Generator")
+        gr.Markdown("Generate images using **pure prompts only** - no automatic enhancements")
         
         # Storage info display
         storage_info = gr.Textbox(
@@ -1087,24 +769,16 @@ def create_gradio_interface():
                 style_dropdown = gr.Dropdown(
                     label="Art Style",
                     choices=["childrens_book", "realistic", "fantasy", "anime"],
-                    value="childrens_book"
-                )
-                
-                # Dynamic character input for testing
-                character_names_input = gr.Textbox(
-                    label="Character Names (comma-separated)",
-                    placeholder="Enter character names: Sparkle the Star Cat, Benny the Bunny, Tilly the Turtle",
-                    info="Enter character names to test consistency features",
-                    lines=2
+                    value="anime"
                 )
                 
                 prompt_input = gr.Textbox(
-                    label="Scene Description",
-                    placeholder="Describe your scene with character interactions...\nExample: Sparkle the Star Cat chasing butterflies while Benny the Bunny watches",
+                    label="Pure Prompt",
+                    placeholder="Enter your exact prompt...",
                     lines=3
                 )
                 
-                generate_btn = gr.Button("✨ Generate Premium Image", variant="primary")
+                generate_btn = gr.Button("✨ Generate Image", variant="primary")
                 
                 # Current image management
                 current_file_path = gr.State()
@@ -1116,65 +790,13 @@ def create_gradio_interface():
                 **For complete storybooks (OCI bucket):**
                 - Endpoint: `POST /api/generate-storybook`
                 - Input: `story_title`, `scenes[]`, `characters[]`
-                - Output: Saves to OCI bucket with dynamic character consistency
+                - Output: Uses pure prompts only from your script
                 """)
             
             with gr.Column(scale=2):
                 image_output = gr.Image(label="Generated Image", height=500, show_download_button=True)
                 status_output = gr.Textbox(label="Status", interactive=False, lines=4)
         
-        # Dynamic character guidance section
-        with gr.Accordion("👥 Dynamic Character Guidance", open=False):
-            gr.Markdown("""
-            ### How to Use Dynamic Characters from n8n:
-            
-            **n8n Payload Structure:**
-            ```json
-            {
-              "story_title": "Your Story Title",
-              "characters": [
-                {
-                  "name": "Character Name",
-                  "description": "Character description...",
-                  "visual_prompt": "Detailed visual description",  // Optional
-                  "key_features": ["feature1", "feature2"]         // Optional
-                }
-              ],
-              "scenes": [
-                {
-                  "visual": "Scene description with characters...",
-                  "text": "Scene text...",
-                  "characters_present": ["Character Name"]         // Optional
-                }
-              ]
-            }
-            ```
-            
-            **Features:**
-            - ✅ Dynamic character processing from n8n
-            - ✅ Automatic visual prompt generation
-            - ✅ Key feature extraction
-            - ✅ Cross-scene consistency
-            - ✅ Flexible character numbers and types
-            """)
-        
-        # Examples section
-        with gr.Accordion("💡 Prompt Examples & Tips", open=False):
-            gr.Markdown("""
-            ## 🎨 Professional Prompt Examples with Dynamic Characters:
-            
-            **Best Results with Dynamic Characters:**
-            - "Sparkle the Star Cat chasing butterflies in a sunny meadow"
-            - "Benny the Bunny and Tilly the Turtle having a picnic"
-            - "Multiple characters discovering a magical portal together"
-            
-            ## ⚡ Dynamic Character Consistency Tips:
-            1. **Always mention character names** in your prompts
-            2. **n8n will send character details** automatically
-            3. **The system processes any number** of characters dynamically
-            4. **Consistency is maintained** across all scenes automatically
-            """)
-        
         # Local file management section
         with gr.Accordion("📁 Manage Local Test Images", open=True):
             gr.Markdown("### Locally Saved Images")
@@ -1193,27 +815,41 @@ def create_gradio_interface():
             
             clear_status = gr.Textbox(label="Clear Status", interactive=False)
         
-        # Debug section
-        with gr.Accordion("🔧 Advanced Settings", open=False):
-            debug_btn = gr.Button("🔄 Check System Status", variant="secondary")
-            debug_output = gr.Textbox(label="System Info", interactive=False, lines=4)
-        
-        def check_system_status():
-            """Check system status"""
-            active_jobs = len(job_storage)
-            return f"""**System Status:**
-- Model: {current_model_name}
-- Dynamic Character Processing: ✅ Enabled
-- Fallback Templates: {len(FALLBACK_CHARACTER_TEMPLATES)} available
-- OCI API: {OCI_API_BASE_URL}
-- Local Storage: {get_local_storage_info().get('total_files', 0)} images
-- Active Jobs: {active_jobs}
-- Ready for dynamic character consistency generation!"""
+        def delete_current_image(filepath):
+            """Delete the currently displayed image"""
+            if not filepath:
+                return "❌ No image to delete", None, None, refresh_local_images()
+            
+            success, message = delete_local_image(filepath)
+            updated_files = refresh_local_images()
+            
+            if success:
+                status_msg = f"✅ {message}"
+                return status_msg, None, "Image deleted successfully!", updated_files
+            else:
+                return f"❌ {message}", None, "Delete failed", updated_files
+
+        def clear_all_images():
+            """Delete all local images"""
+            try:
+                storage_info = get_local_storage_info()
+                deleted_count = 0
+                
+                if "images" in storage_info:
+                    for image_info in storage_info["images"]:
+                        success, _ = delete_local_image(image_info["path"])
+                        if success:
+                            deleted_count += 1
+                
+                updated_files = refresh_local_images()
+                return f"✅ Deleted {deleted_count} images", updated_files
+            except Exception as e:
+                return f"❌ Error: {str(e)}", refresh_local_images()
 
         # Connect buttons to functions
         generate_btn.click(
-            fn=generate_test_image_with_characters,
-            inputs=[prompt_input, model_dropdown, style_dropdown, character_names_input],
+            fn=generate_test_image_simple,
+            inputs=[prompt_input, model_dropdown, style_dropdown],
             outputs=[image_output, status_output, current_file_path]
         ).then(
             fn=refresh_local_images,
@@ -1248,26 +884,20 @@ def create_gradio_interface():
             outputs=storage_info
         )
         
-        debug_btn.click(
-            fn=check_system_status,
-            inputs=None,
-            outputs=debug_output
-        )
-        
         # Initialize on load
         demo.load(fn=refresh_local_images, outputs=file_gallery)
         demo.load(fn=update_storage_info, outputs=storage_info)
     
     return demo
 
-# Create enhanced Gradio app
+# Create simple Gradio app
 demo = create_gradio_interface()
 
-# Enhanced root endpoint that explains the API structure
+# Simple root endpoint
 @app.get("/")
 async def root():
     return {
-        "message": "Storybook Generator API with Dynamic Character Consistency is running!",
+        "message": "Simple Storybook Generator API is running!",
         "api_endpoints": {
             "health_check": "GET /api/health",
             "generate_storybook": "POST /api/generate-storybook",
@@ -1275,13 +905,10 @@ async def root():
             "local_images": "GET /api/local-images"
         },
         "features": {
-            "dynamic_characters": "✅ Enabled",
-            "character_consistency": "✅ Enabled", 
-            "flexible_storytelling": "✅ Enabled",
+            "pure_prompts": "✅ Enabled - No automatic enhancements",
             "n8n_integration": "✅ Enabled"
         },
-        "web_interface": "GET /ui",
-        "note": "Use API endpoints for programmatic access with dynamic characters from n8n"
+        "web_interface": "GET /ui"
     }
 
 # Add a simple test endpoint
@@ -1289,9 +916,8 @@ async def root():
 async def test_endpoint():
     return {
         "status": "success", 
-        "message": "API with dynamic character consistency is working correctly",
-        "dynamic_processing": "✅ Enabled",
-        "fallback_templates": len(FALLBACK_CHARACTER_TEMPLATES),
+        "message": "API with pure prompts is working correctly",
+        "pure_prompts": "✅ Enabled - Using exact prompts from Telegram",
         "timestamp": datetime.now().isoformat()
     }
 
@@ -1310,8 +936,7 @@ if __name__ == "__main__":
         print("🚀 Running on Hugging Face Spaces - Integrated Mode")
         print("📚 API endpoints available at: /api/*")
         print("🎨 Web interface available at: /ui")
-        print("👥 Dynamic character consistency features enabled")
-        print("🔌 Both API and UI running on same port")
+        print("📝 PURE PROMPTS enabled - no automatic enhancements")
         
         # Mount Gradio without reassigning app
         gr.mount_gradio_app(app, demo, path="/ui")
@@ -1328,7 +953,7 @@ if __name__ == "__main__":
         print("🚀 Running locally - Separate API and UI servers")
         print("📚 API endpoints: http://localhost:8000/api/*")
         print("🎨 Web interface: http://localhost:7860/ui")
-        print("👥 Dynamic character consistency features enabled")
+        print("📝 PURE PROMPTS enabled - no automatic enhancements")
         
         def run_fastapi():
             """Run FastAPI on port 8000 for API calls"""
@@ -1344,25 +969,4 @@ if __name__ == "__main__":
             """Run Gradio on port 7860 for web interface"""
             demo.launch(
                 server_name="0.0.0.0",
-                server_port=7860,
-                share=False,
-                show_error=True,
-                quiet=True
-            )
-        
-        # Start both servers in separate threads
-        api_thread = threading.Thread(target=run_fastapi, daemon=True)
-        ui_thread = threading.Thread(target=run_gradio, daemon=True)
-        
-        api_thread.start()
-        print("✅ FastAPI server started on port 8000")
-        
-        ui_thread.start()
-        print("✅ Gradio server started on port 7860")
-        
-        # Keep the main thread alive
-        try:
-            while True:
-                time.sleep(1)
-        except KeyboardInterrupt:
-            print("🛑 Shutting down servers...")
+