app_backeu.py

#Error communicating with the chatbot API: Object of type Textbox is not JSON serializable

import gradio as gr
import requests
from PIL import Image
import os 
import io
from transformers import BlipProcessor, BlipForConditionalGeneration
import time
from gradio_client import Client

token = os.getenv('HF_TOKEN')
blipper="Salesforce/blip-image-captioning-large"
chatter="K00B404/transcript_image_generator"

# Set your API endpoint and authorization details
API_URL = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"
headers = {"Authorization": f"Bearer {token}"}  # Replace with your actual token
timeout = 60  # seconds

# Load BLIP model for image captioning
processor = BlipProcessor.from_pretrained(blipper)
model = BlipForConditionalGeneration.from_pretrained(blipper)

# Initialize the API client for the chatbot
chatbot_client = Client(chatter)

def caption_to_persona(caption):
    """Convert a basic image caption into a character persona prompt"""
    persona = f"""You are {caption.replace('arafed image of ','a ').replace('arafed ','a ')}

Your personality, speech patterns, knowledge, and behavior should reflect this description.
When responding to users:
1. Stay in character at all times
2. Use speech patterns and vocabulary that would be natural for your character
3. Reference experiences, emotions, and perspectives that align with your character's background
4. Maintain a consistent personality throughout the conversation

Additional context: Your responses should vary in length based on what would be natural for your character. 
Some characters might be terse while others might be more verbose."""

    return persona


def helper_llm(message, system_prompt, max_tokens=256, temperature=0.5, top_p=0.95):
    """Function to interact with the chatbot API using the generated persona"""
    
    try:
        # Call the API with the current message and system prompt (persona)
        response = chatbot_client.predict(
            message=message,
            system_message=system_prompt,
            max_tokens=max_tokens,
            temperature=temperature,
            top_p=top_p,
            api_name="/chat"
        )
        return response
    except Exception as e:
        return f"Error communicating with the chatbot API: {str(e)}"

def generate_persona(img, min_len, max_len, persona_detail_level):
    # Process the image
    raw_image = Image.open(img).convert('RGB')

    # Resize image to 512x512
    raw_image = raw_image.resize((256, 256), Image.Resampling.LANCZOS)
    
    
    inputs = processor(raw_image, return_tensors="pt")
    
    # Generate caption with specified length constraints
    start = time.time()
    out = model.generate(**inputs, min_length=min_len, max_length=max_len)
    caption = processor.decode(out[0], skip_special_tokens=True)
    
    # Enhance the caption based on detail level
    if persona_detail_level == "Basic":
        enhanced_caption = caption
    elif persona_detail_level == "Detailed":
        enhanced_caption = f"{caption} You have a distinct personality with unique mannerisms and speech patterns."
    else:  # Comprehensive
        enhanced_caption = f"{caption} You have a complex backstory, rich emotional depth, unique perspectives, and distinctive speech patterns that set you apart."
    
    # Generate persona from caption
    persona = caption_to_persona(enhanced_caption)
    
    # Calculate processing time
    end = time.time()
    total_time = f"Processing time: {end - start:.2f} seconds"
   
    # dramaturg to mae a solid role for a actor from pragmatic description
    system_prompt="You are a Expert Dramaturg and your task is to use the input persona information and write a 'Role' description as compact instuctions for the actor"
    persona = helper_llm(persona, system_prompt=system_prompt)
    return caption, persona, total_time


def chat_with_persona(message, history, system_message, max_tokens, temperature, top_p):
    """Function to interact with the chatbot API using the generated persona"""
    try:
        # Call the API with the current message and system prompt (persona)
        response = chatbot_client.predict(
            message=message,
            system_message=system_message,
            max_tokens=max_tokens,
            temperature=temperature,
            top_p=top_p,
            api_name="/chat"
        )
        return response
    except Exception as e:
        return f"Error communicating with the chatbot API: {str(e)}"





def generate_flux_image(final_prompt, is_negative, steps, cfg_scale, seed, strength):
    """
    Generate an image using the FLUX model via Hugging Face's inference API.
    The function sends a POST request with the given payload and returns the image,
    along with the seed and prompt used.
    """
    payload = {
        "inputs": final_prompt,
        "is_negative": is_negative,
        "steps": steps,
        "cfg_scale": cfg_scale,
        "seed": seed,
        "strength": strength
    }
    
    response = requests.post(API_URL, headers=headers, json=payload, timeout=timeout)
    
    if response.status_code != 200:
        print(f"Error: Failed to get image. Response status: {response.status_code}")
        print(f"Response content: {response.text}")
        if response.status_code == 503:
            raise gr.Error(f"{response.status_code} : The model is being loaded")
        raise gr.Error(f"{response.status_code}")
    
    try:
        image_bytes = response.content
        image = Image.open(io.BytesIO(image_bytes))
        # Optionally save the image to a file (filename based on seed)
        output_path = f"./output_{seed}.png"
        image.save(output_path)
        print(f'\033[1mGeneration completed!\033[0m (Prompt: {final_prompt})')
        return output_path, str(seed), final_prompt
    except Exception as e:
        print(f"Error when trying to open the image: {e}")
        return None, None, None


        
# Create Gradio interface with tabs
with gr.Blocks(title="Image Character Persona Generator") as iface:
    # Store the generated persona in a state variable to share between tabs
    persona_state = gr.State("")
    
    with gr.Tabs():
        # First tab: Persona Generator
        with gr.TabItem("Generate Persona"):
            gr.Markdown("# Image Character Persona Generator")
            gr.Markdown("Upload an image containing a character to generate an LLM persona based on that character.")
            
            with gr.Row():
                with gr.Column():
                    input_image = gr.Image(type='filepath', label='Character Image')
                    min_length = gr.Slider(label='Minimum Description Length', minimum=10, maximum=500, value=50, step=5)
                    max_length = gr.Slider(label='Maximum Description Length', minimum=50, maximum=1000, value=200, step=10)
                    detail_level = gr.Radio(["Basic", "Detailed", "Comprehensive"], label="Persona Detail Level", value="Comprehensive")
                    submit_btn = gr.Button("Generate Character Persona")
                
                with gr.Column():
                    caption_output = gr.Textbox(label='Character Description (Base Caption)')
                    persona_output = gr.Textbox(label='LLM Character Persona Prompt', lines=10)
                    time_output = gr.Textbox(label='Processing Information')
            
            gr.Markdown("""
            ## How to use this tool
            1. Upload an image containing a character (real or fictional)
            2. Adjust the sliders to control description length
            3. Select detail level for the persona
            4. Click "Generate Character Persona"
            5. Switch to the "Test Persona" tab to chat with your character
            6. create similar images inspired by the 'role' 
            """)
        
        # Second tab: Test Character Chat
        with gr.TabItem("Test Persona"):
            gr.Markdown("# Test Your Character Persona")
            gr.Markdown("Chat with an AI using your generated character persona to see how it behaves.")
            
            with gr.Row():
                with gr.Column():
                    system_prompt = gr.Textbox(label="Character Persona (System Prompt)", lines=8)
                    
                    with gr.Accordion("Advanced Settings", open=False):
                        max_tokens = gr.Slider(label="Max Tokens", minimum=50, maximum=2048, value=512, step=1)
                        temperature = gr.Slider(label="Temperature", minimum=0.1, maximum=1.5, value=0.7, step=0.1)
                        top_p = gr.Slider(label="Top P", minimum=0.1, maximum=1.0, value=0.95, step=0.05)
                
                with gr.Column():
                    chatbot = gr.Chatbot(label="Conversation with Character")
                    msg = gr.Textbox(label="Your message")
                    clear_btn = gr.Button("Clear Conversation")
            
            # Handle sending messages in the chat
            def respond(message, chat_history, system_message, max_tokens, temperature, top_p):
                if not message.strip():
                    return "", chat_history
                
                # Add user message to history
                chat_history.append((message, ""))
                
                # Get response from API
                bot_response = chat_with_persona(message, chat_history, system_message, max_tokens, temperature, top_p)
                
                # Update the last response in history
                chat_history[-1] = (message, bot_response)
                
                return "", chat_history
            
            # Clear chat history
            def clear_chat():
                return []
            
            # Connect message input to chat response
            msg.submit(respond, 
                      [msg, chatbot, system_prompt, max_tokens, temperature, top_p], 
                      [msg, chatbot])
            
            clear_btn.click(clear_chat, outputs=chatbot)


        # New Tab 3: Flux Image Generation
        with gr.Tab("Flux Image Generation"):
            gr.Markdown("### Flux Image Generation")
            final_prompt = gr.Textbox(label="Prompt", lines=2, placeholder="Enter your prompt for Flux...")
            is_negative = gr.Checkbox(label="Use Negative Prompt", value=False)
            steps = gr.Slider(minimum=10, maximum=100, step=1, value=50, label="Steps")
            cfg_scale = gr.Slider(minimum=1, maximum=20, step=1, value=7, label="CFG Scale")
            seed = gr.Number(value=42, label="Seed")
            strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=0.8, label="Strength")
            
            generate_button = gr.Button("Generate Flux Image")
            output_image = gr.Image(label="Generated Image")
            output_seed = gr.Textbox(label="Seed Used")
            output_prompt = gr.Textbox(label="Prompt Used")
            
            generate_button.click(
                fn=generate_flux_image, 
                inputs=[final_prompt, is_negative, steps, cfg_scale, seed, strength], 
                outputs=[output_image, output_seed, output_prompt]
            )



    
    # Function to update system prompt in Test tab when persona is generated
    def update_persona_state(caption, persona, time_output):
        return persona, persona
    
    # Connect the persona generator to update the system prompt
    submit_btn.click(fn=generate_persona, 
                    inputs=[input_image, min_length, max_length, detail_level],
                    outputs=[caption_output, persona_output, time_output])
    
    # Update the system prompt in Test tab when persona is generated
    submit_btn.click(fn=update_persona_state,
                    inputs=[caption_output, persona_output, time_output],
                    outputs=[persona_state, system_prompt])

# Launch the interface
iface.launch()