Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import google.generativeai as genai | |
| import os | |
| import mimetypes | |
| from PIL import Image | |
| import io | |
| import magic # python-magic library | |
| from dotenv import load_dotenv | |
| # (Optional) Load environment variables for local testing if you have a .env file | |
| # load_dotenv() | |
| # TEST_API_KEY = os.getenv("GEMINI_API_KEY") # Use this ONLY for your local testing | |
| # --- Constants --- | |
| # Define available models (expand this list as needed) | |
| # Include models supporting different modalities and versions | |
| AVAILABLE_MODELS = [ | |
| "gemini-1.5-flash-latest", | |
| "gemini-1.5-pro-latest", | |
| "gemini-1.0-pro", | |
| "gemini-pro-vision", # Example vision model | |
| # "gemini-experimental", # Add other relevant models | |
| ] | |
| # Define parameters for each model (Example structure) | |
| # This needs meticulous mapping based on official Gemini documentation | |
| MODEL_PARAMS = { | |
| "gemini-1.5-flash-latest": { | |
| "temperature": {"type": "slider", "min": 0.0, "max": 2.0, "step": 0.1, "default": 1.0}, | |
| "top_p": {"type": "slider", "min": 0.0, "max": 1.0, "step": 0.01, "default": 0.95}, | |
| "top_k": {"type": "slider", "min": 1, "max": 100, "step": 1, "default": 40}, | |
| "max_output_tokens": {"type": "number", "min": 1, "step": 1, "default": 8192}, | |
| "stop_sequences": {"type": "textbox", "lines": 1, "placeholder": "e.g., END,STOP", "default": ""}, | |
| # Safety settings could be added here too (as dropdowns or checkboxes) | |
| }, | |
| "gemini-1.5-pro-latest": { | |
| # Similar params, possibly different defaults or ranges | |
| "temperature": {"type": "slider", "min": 0.0, "max": 2.0, "step": 0.1, "default": 1.0}, | |
| "top_p": {"type": "slider", "min": 0.0, "max": 1.0, "step": 0.01, "default": 0.95}, | |
| "top_k": {"type": "slider", "min": 1, "max": 100, "step": 1, "default": 40}, | |
| "max_output_tokens": {"type": "number", "min": 1, "step": 1, "default": 8192}, | |
| "stop_sequences": {"type": "textbox", "lines": 1, "placeholder": "e.g., END,STOP", "default": ""}, | |
| }, | |
| "gemini-1.0-pro": { | |
| # Params for older model might differ slightly | |
| "temperature": {"type": "slider", "min": 0.0, "max": 1.0, "step": 0.1, "default": 0.9}, # Different max/default maybe | |
| "top_p": {"type": "slider", "min": 0.0, "max": 1.0, "step": 0.01, "default": 0.95}, | |
| "top_k": {"type": "slider", "min": 1, "max": 100, "step": 1, "default": 40}, | |
| "max_output_tokens": {"type": "number", "min": 1, "step": 1, "default": 2048}, # Different default | |
| "stop_sequences": {"type": "textbox", "lines": 1, "placeholder": "e.g., END,STOP", "default": ""}, | |
| }, | |
| "gemini-pro-vision": { | |
| # Vision models might have fewer text-generation params or different ones | |
| "temperature": {"type": "slider", "min": 0.0, "max": 1.0, "step": 0.1, "default": 0.4}, | |
| "top_p": {"type": "slider", "min": 0.0, "max": 1.0, "step": 0.01, "default": 0.95}, | |
| "top_k": {"type": "slider", "min": 1, "max": 100, "step": 1, "default": 32}, | |
| "max_output_tokens": {"type": "number", "min": 1, "step": 1, "default": 2048}, | |
| # No stop sequences typically needed here? Check docs. | |
| } | |
| } | |
| # --- Helper Functions --- | |
| def get_mime_type(file_path): | |
| """Get MIME type using python-magic for reliability.""" | |
| try: | |
| mime = magic.Magic(mime=True) | |
| return mime.from_file(file_path) | |
| except Exception: | |
| # Fallback to mimetypes if magic fails | |
| return mimetypes.guess_type(file_path)[0] | |
| def convert_file_to_text(file_obj): | |
| """ | |
| Attempts to convert various file types to text. | |
| Returns (text_content, original_filename) or (None, original_filename) if conversion fails. | |
| """ | |
| file_path = file_obj.name | |
| filename = os.path.basename(file_path) | |
| mime_type = get_mime_type(file_path) | |
| print(f"Processing file: {filename}, MIME type: {mime_type}") # Debugging | |
| try: | |
| if mime_type is None: | |
| # If MIME type is unknown, try reading as text | |
| print(f"Warning: Unknown MIME type for {filename}. Attempting to read as text.") | |
| with open(file_path, 'r', encoding='utf-8', errors='ignore') as f: | |
| return f.read(), filename | |
| elif mime_type.startswith("text/"): | |
| with open(file_path, 'r', encoding='utf-8', errors='ignore') as f: | |
| return f.read(), filename | |
| elif mime_type == "application/pdf": | |
| # Placeholder for PDF conversion (requires pypdf or similar) | |
| print(f"PDF conversion not implemented yet for {filename}.") | |
| # from pypdf import PdfReader # Example | |
| # reader = PdfReader(file_path) | |
| # text = "" | |
| # for page in reader.pages: | |
| # text += page.extract_text() + "\n" | |
| # return text, filename | |
| return f"[Unsupported PDF: {filename} - Conversion not implemented]", filename # Temporary | |
| elif mime_type in ["application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"]: | |
| # Placeholder for DOCX conversion (requires python-docx or similar) | |
| print(f"DOCX conversion not implemented yet for {filename}.") | |
| # import docx # Example | |
| # doc = docx.Document(file_path) | |
| # text = "\n".join([para.text for para in doc.paragraphs]) | |
| # return text, filename | |
| return f"[Unsupported Word Doc: {filename} - Conversion not implemented]", filename # Temporary | |
| else: | |
| # For other unsupported types, return a marker | |
| print(f"Unsupported file type: {mime_type} for {filename}. Skipping content.") | |
| return f"[Unsupported file type: {mime_type} - {filename}]", filename | |
| except Exception as e: | |
| print(f"Error converting file {filename}: {e}") | |
| return f"[Error converting file: {filename}]", filename | |
| def prepare_gemini_input(prompt, files): | |
| """Prepares the input list for Gemini, handling text and images.""" | |
| gemini_parts = [] | |
| if prompt: | |
| gemini_parts.append(prompt) | |
| if files: | |
| for file_obj in files: | |
| file_path = file_obj.name | |
| mime_type = get_mime_type(file_path) | |
| filename = os.path.basename(file_path) | |
| print(f"Preparing file for Gemini: {filename}, MIME: {mime_type}") | |
| if mime_type and mime_type.startswith("image/"): | |
| try: | |
| img = Image.open(file_path) | |
| # Convert image to bytes (e.g., PNG or JPEG) | |
| # Gemini API directly accepts PIL Images usually | |
| gemini_parts.append(img) | |
| print(f"Added image: {filename}") | |
| except Exception as e: | |
| print(f"Error processing image {filename}: {e}") | |
| gemini_parts.append(f"[Error processing image: {filename}]") | |
| elif mime_type and mime_type.startswith("video/"): # Gemini 1.5 Pro can handle video | |
| # Upload file via File API first (more complex, needs google.ai.generativelanguage) | |
| # For simplicity here, we'll just note it's a video | |
| # or provide a basic text representation if conversion isn't implemented | |
| print(f"Video file detected: {filename}. Full video processing requires File API.") | |
| gemini_parts.append(f"[Video file: {filename} - Requires File API upload]") | |
| # Placeholder: Add text conversion if feasible for your use case | |
| # text_content, _ = convert_file_to_text(file_obj) | |
| # if text_content: | |
| # gemini_parts.append(f"--- Content of video file {filename} (extracted as text) ---\n{text_content}") | |
| elif mime_type and mime_type.startswith("audio/"): # Gemini 1.5 Pro can handle audio | |
| print(f"Audio file detected: {filename}. Full audio processing requires File API.") | |
| gemini_parts.append(f"[Audio file: {filename} - Requires File API upload]") | |
| # Placeholder: Add text conversion if feasible (e.g. transcript) | |
| # text_content, _ = convert_file_to_text(file_obj) # Needs specific audio-to-text logic | |
| # if text_content: | |
| # gemini_parts.append(f"--- Content of audio file {filename} (extracted as text) ---\n{text_content}") | |
| else: # Assume text or convertible to text | |
| text_content, original_filename = convert_file_to_text(file_obj) | |
| if text_content: | |
| # Add context marker | |
| gemini_parts.append(f"\n--- Content from file: {original_filename} ---\n{text_content}\n--- End of file: {original_filename} ---") | |
| else: | |
| gemini_parts.append(f"[Could not process file: {original_filename}]") | |
| # Ensure there's at least one part (maybe an empty string if only files were given?) | |
| if not gemini_parts: | |
| gemini_parts.append("") # Avoid sending empty list | |
| return gemini_parts | |
| # --- Gradio UI Functions --- | |
| def validate_api_key(api_key): | |
| """Checks if the API key is potentially valid by trying to list models.""" | |
| if not api_key: | |
| return "<p style='color: orange;'>Please enter an API Key.</p>" | |
| try: | |
| genai.configure(api_key=api_key) | |
| models = genai.list_models() | |
| # Check if at least one desired model is available with this key | |
| available_core_models = [m.name for m in models if 'generateContent' in m.supported_generation_methods] | |
| if any(model_name.split('/')[-1] in AVAILABLE_MODELS for model_name in available_core_models): | |
| return "<p style='color: green;'>API Key seems valid (can list models).</p>" | |
| else: | |
| return "<p style='color: orange;'>API Key is valid but might not have access to the required Gemini models.</p>" | |
| except Exception as e: | |
| print(f"API Key validation error: {e}") | |
| # Be careful not to leak too much error detail | |
| if "API key not valid" in str(e): | |
| return "<p style='color: red;'>API Key is invalid.</p>" | |
| else: | |
| return f"<p style='color: red;'>API Key validation failed. Error: {str(e)}</p>" | |
| def update_parameter_visibility(model_name): | |
| """Updates visibility and values of parameter controls based on selected model.""" | |
| updates = {} | |
| params_for_model = MODEL_PARAMS.get(model_name, {}) | |
| # Define ALL possible parameter components used across models | |
| all_param_keys = set(k for params in MODEL_PARAMS.values() for k in params) | |
| for key in all_param_keys: | |
| param_config = params_for_model.get(key) | |
| if param_config: | |
| # Parameter exists for this model: make visible and set defaults | |
| updates[param_elements[key]] = gr.update( | |
| visible=True, | |
| label=key.replace("_", " ").title(), # Nicer label | |
| value=param_config.get("default") # Set default value | |
| # Add specific updates for slider ranges etc. if needed | |
| # minimum=param_config.get("min"), | |
| # maximum=param_config.get("max"), | |
| # step=param_config.get("step") | |
| ) | |
| else: | |
| # Parameter does NOT exist for this model: hide it | |
| updates[param_elements[key]] = gr.update(visible=False, value=None) # Reset value when hiding | |
| return updates | |
| def handle_chat(api_key, model_name, history, message, files, *params_tuple): | |
| """Handles the chat interaction.""" | |
| # 1. Basic Validation | |
| if not api_key: | |
| gr.Warning("Gemini API Key is missing!") | |
| return history, "" # Return unchanged history and empty textbox | |
| if not message and not files: | |
| gr.Warning("Please enter a message or upload files.") | |
| return history, "" | |
| # 2. Configure API Key | |
| try: | |
| genai.configure(api_key=api_key) | |
| except Exception as e: | |
| gr.Error(f"Failed to configure API Key: {e}") | |
| return history, message # Keep message in textbox for retry | |
| # 3. Prepare Generation Config from *params_tuple | |
| param_keys = [key for key, config in MODEL_PARAMS.get(model_name, {}).items()] | |
| generation_config_dict = {} | |
| if len(params_tuple) == len(param_keys): | |
| generation_config_dict = {key: val for key, val in zip(param_keys, params_tuple) if val is not None} | |
| # Handle stop sequences (expecting comma-separated string) | |
| if 'stop_sequences' in generation_config_dict and isinstance(generation_config_dict['stop_sequences'], str): | |
| sequences = [s.strip() for s in generation_config_dict['stop_sequences'].split(',') if s.strip()] | |
| if sequences: | |
| generation_config_dict['stop_sequences'] = sequences | |
| else: | |
| del generation_config_dict['stop_sequences'] # Remove if empty/invalid | |
| print(f"Using Generation Config: {generation_config_dict}") # Debug | |
| else: | |
| print(f"Warning: Mismatch between expected params ({len(param_keys)}) and received params ({len(params_tuple)})") | |
| # 4. Prepare Model Input | |
| gemini_input_parts = prepare_gemini_input(message, files) | |
| print(f"Prepared Gemini Input Parts: {gemini_input_parts}") # Debugging | |
| # 5. Initialize Model and Chat | |
| try: | |
| # Add safety settings if needed/configured | |
| # safety_settings = {...} | |
| model = genai.GenerativeModel(model_name)#, safety_settings=safety_settings) | |
| # Convert Gradio history (list of lists) to Gemini format (list of Content objects) | |
| gemini_history = [] | |
| for user_msg, model_msg in history: | |
| # Simple text history for now. Need enhancement for multimodal history. | |
| if user_msg: gemini_history.append({'role': 'user', 'parts': [user_msg]}) | |
| if model_msg: gemini_history.append({'role': 'model', 'parts': [model_msg]}) | |
| chat = model.start_chat(history=gemini_history) | |
| print(f"Starting chat with history (simplified): {gemini_history}") # Debugging | |
| except Exception as e: | |
| gr.Error(f"Failed to initialize model or chat: {e}") | |
| return history, message # Keep message in textbox | |
| # 6. Send Message and Get Response | |
| response_text = "" | |
| try: | |
| # Use streaming for better UX in chat | |
| response = chat.send_message(gemini_input_parts, | |
| generation_config=genai.types.GenerationConfig(**generation_config_dict), | |
| stream=True) | |
| full_response_content = "" | |
| for chunk in response: | |
| # Check if the chunk has text content | |
| if hasattr(chunk, 'text'): | |
| chunk_text = chunk.text | |
| print(f"Stream chunk: {chunk_text}") # Debug stream | |
| full_response_content += chunk_text | |
| # Yield intermediate updates to the chatbot | |
| current_history = history + [[message or "[Input files only]", full_response_content]] | |
| yield current_history, "" # Update chatbot, clear input | |
| # Check for image data if model supports it (more complex parsing needed) | |
| # elif chunk.parts and chunk.parts[0].inline_data: | |
| # # Handle potential image output - requires modification | |
| # pass | |
| response_text = full_response_content # Final text response | |
| # Check for blocked prompts or safety issues | |
| if not response_text and response.prompt_feedback.block_reason: | |
| block_reason = response.prompt_feedback.block_reason | |
| safety_ratings = response.prompt_feedback.safety_ratings | |
| gr.Warning(f"Request blocked. Reason: {block_reason}. Ratings: {safety_ratings}") | |
| # Append a notice to history instead of an empty response | |
| history.append([message or "[Input files only]", f"[Request blocked due to: {block_reason}]"]) | |
| return history, "" # Clear input box | |
| except Exception as e: | |
| gr.Error(f"Error during generation: {e}") | |
| # Optionally add the error to history for context | |
| history.append([message or "[Input files only]", f"[Error during generation: {str(e)}]"]) | |
| return history, "" # Clear input box | |
| # 7. Update History and Clear Input | |
| # The yielding above handles intermediate updates. This is the final state. | |
| final_history = history + [[message or "[Input files only]", response_text or "[No text content received]"]] | |
| return final_history, "" # Final update, clear input | |
| def handle_single_response(api_key, model_name, prompt, files, *params_tuple): | |
| """Handles the single response interaction.""" | |
| # 1. Validations | |
| if not api_key: | |
| gr.Warning("Gemini API Key is missing!") | |
| return "[Error: API Key Missing]", None # Text output, Image output | |
| if not prompt and not files: | |
| gr.Warning("Please enter a prompt or upload files.") | |
| return "[Error: No input provided]", None | |
| # 2. Configure API Key | |
| try: | |
| genai.configure(api_key=api_key) | |
| except Exception as e: | |
| gr.Error(f"Failed to configure API Key: {e}") | |
| return f"[Error: API Key Config Failed: {e}]", None | |
| # 3. Prepare Generation Config | |
| param_keys = [key for key, config in MODEL_PARAMS.get(model_name, {}).items()] | |
| generation_config_dict = {} | |
| if len(params_tuple) == len(param_keys): | |
| generation_config_dict = {key: val for key, val in zip(param_keys, params_tuple) if val is not None} | |
| # Handle stop sequences | |
| if 'stop_sequences' in generation_config_dict and isinstance(generation_config_dict['stop_sequences'], str): | |
| sequences = [s.strip() for s in generation_config_dict['stop_sequences'].split(',') if s.strip()] | |
| if sequences: | |
| generation_config_dict['stop_sequences'] = sequences | |
| else: | |
| del generation_config_dict['stop_sequences'] | |
| print(f"Using Generation Config: {generation_config_dict}") # Debug | |
| else: | |
| print(f"Warning: Mismatch between expected params ({len(param_keys)}) and received params ({len(params_tuple)})") | |
| # 4. Prepare Model Input | |
| gemini_input_parts = prepare_gemini_input(prompt, files) | |
| print(f"Prepared Gemini Input Parts: {gemini_input_parts}") # Debugging | |
| # 5. Initialize Model | |
| try: | |
| # Add safety settings if needed/configured | |
| model = genai.GenerativeModel(model_name) | |
| except Exception as e: | |
| gr.Error(f"Failed to initialize model: {e}") | |
| return f"[Error: Model Initialization Failed: {e}]", None | |
| # 6. Generate Content (Non-streaming for single response usually) | |
| output_text = "[No text content generated]" | |
| output_image = None # Placeholder for image output | |
| try: | |
| response = model.generate_content( | |
| gemini_input_parts, | |
| generation_config=genai.types.GenerationConfig(**generation_config_dict), | |
| stream=False # Simpler for single turn unless very long output expected | |
| ) | |
| # Check for blocked prompts or safety issues | |
| if response.prompt_feedback.block_reason: | |
| block_reason = response.prompt_feedback.block_reason | |
| safety_ratings = response.prompt_feedback.safety_ratings | |
| gr.Warning(f"Request blocked. Reason: {block_reason}. Ratings: {safety_ratings}") | |
| return f"[Request blocked due to: {block_reason}]", None | |
| # Process response parts (could contain text and/or images) | |
| # This part needs refinement based on how Gemini API returns mixed content | |
| # For now, prioritize text and assume first image part if present | |
| response_text_parts = [] | |
| for part in response.parts: | |
| if hasattr(part, 'text'): | |
| response_text_parts.append(part.text) | |
| elif hasattr(part, 'inline_data') and part.inline_data.mime_type.startswith('image/'): | |
| if output_image is None: # Display the first image found | |
| try: | |
| image_data = part.inline_data.data | |
| img = Image.open(io.BytesIO(image_data)) | |
| output_image = img | |
| print("Image received in response.") | |
| except Exception as img_err: | |
| print(f"Error decoding image from response: {img_err}") | |
| response_text_parts.append("[Error decoding image in response]") | |
| if response_text_parts: | |
| output_text = "\n".join(response_text_parts) | |
| elif hasattr(response, 'text'): # Fallback if parts parsing fails but text attribute exists | |
| output_text = response.text | |
| # Check if only an image was returned (or intended) | |
| if not response_text_parts and output_image is not None: | |
| output_text = "[Image generated - see output below]" | |
| except Exception as e: | |
| gr.Error(f"Error during generation: {e}") | |
| output_text = f"[Error during generation: {str(e)}]" | |
| # 7. Return results | |
| return output_text, output_image | |
| # --- Build Gradio Interface --- | |
| with gr.Blocks(theme=gr.themes.Soft()) as demo: | |
| gr.Markdown("# Gemini API Interface") | |
| gr.Markdown("Interact with Google Gemini models using your own API key. Supports chat, single responses, file uploads, and model-specific parameters.") | |
| # API Key Section | |
| with gr.Row(): | |
| api_key_input = gr.Textbox( | |
| label="Gemini API Key", | |
| placeholder="Enter your Gemini API Key here", | |
| type="password", | |
| scale=3 | |
| ) | |
| validate_button = gr.Button("Validate Key", scale=1) | |
| api_key_status = gr.Markdown("<p style='color: gray;'>Enter your key and click Validate.</p>") | |
| # Model Selection | |
| model_dropdown = gr.Dropdown( | |
| label="Select Gemini Model", | |
| choices=AVAILABLE_MODELS, | |
| value=AVAILABLE_MODELS[0], # Default model | |
| ) | |
| # Dynamic Parameters Section (Initially hidden, updated by model selection) | |
| param_elements = {} # Dictionary to hold parameter UI components | |
| with gr.Accordion("Model Parameters", open=False) as params_accordion: | |
| # Create UI elements for ALL possible parameters defined in MODEL_PARAMS | |
| # They will be shown/hidden by the update_parameter_visibility function | |
| all_possible_params = set(k for params in MODEL_PARAMS.values() for k in params) | |
| for param_name in sorted(list(all_possible_params)): # Sort for consistent order | |
| # Determine control type based on the first model that defines it (can be refined) | |
| control_type = "textbox" # Default | |
| config = {} | |
| for model_cfg in MODEL_PARAMS.values(): | |
| if param_name in model_cfg: | |
| config = model_cfg[param_name] | |
| control_type = config.get("type", "textbox") | |
| break # Found config for this param | |
| if control_type == "slider": | |
| param_elements[param_name] = gr.Slider( | |
| label=param_name.replace("_", " ").title(), | |
| minimum=config.get("min", 0), | |
| maximum=config.get("max", 1), | |
| step=config.get("step", 0.1), | |
| value=config.get("default"), | |
| visible=False, # Initially hidden | |
| interactive=True | |
| ) | |
| elif control_type == "number": | |
| param_elements[param_name] = gr.Number( | |
| label=param_name.replace("_", " ").title(), | |
| minimum=config.get("min", 1), | |
| step=config.get("step", 1), | |
| value=config.get("default"), | |
| visible=False, | |
| interactive=True | |
| ) | |
| else: # Default to Textbox for stop_sequences etc. | |
| param_elements[param_name] = gr.Textbox( | |
| label=param_name.replace("_", " ").title(), | |
| lines=config.get("lines", 1), | |
| placeholder=config.get("placeholder", ""), | |
| value=config.get("default", ""), | |
| visible=False, | |
| interactive=True | |
| ) | |
| # Pack the parameter components into a list for function inputs/outputs | |
| # IMPORTANT: The order here MUST match the order expected by handle_chat/handle_single_response | |
| ordered_param_components = [param_elements[key] for key in sorted(param_elements.keys())] | |
| # Main Interaction Area (Tabs) | |
| with gr.Tabs(): | |
| # --- Chat Interface Tab --- | |
| with gr.TabItem("Chat Interface"): | |
| gr.Markdown("Have a conversation with the selected model. Upload files to include their content.") | |
| chat_history_state = gr.State([]) # Holds the conversation history | |
| chatbot_display = gr.Chatbot(label="Conversation", height=500) | |
| with gr.Row(): | |
| chat_file_upload = gr.File(label="Upload Files (Text, Images, etc.)", file_count="multiple") | |
| with gr.Row(): | |
| chat_message_input = gr.Textbox(label="Your Message", placeholder="Type your message here...", scale=4, lines=3) | |
| chat_submit_button = gr.Button("Send", variant="primary", scale=1) | |
| clear_chat_button = gr.Button("Clear Chat History") | |
| # --- Single Response Tab --- | |
| with gr.TabItem("Single Response"): | |
| gr.Markdown("Send a prompt (and optionally files) to get a single response from the model.") | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| single_prompt_input = gr.Textbox(label="Your Prompt", placeholder="Enter your prompt...", lines=5) | |
| single_file_upload = gr.File(label="Upload Files (Text, Images, etc.)", file_count="multiple") | |
| single_submit_button = gr.Button("Generate Response", variant="primary") | |
| with gr.Column(scale=2): | |
| gr.Markdown("**Output:**") | |
| single_output_text = gr.Textbox(label="Text Response", lines=10, interactive=False) | |
| single_output_image = gr.Image(label="Image Response", type="pil", interactive=False) # Display PIL images | |
| # --- Event Wiring --- | |
| # 1. API Key Validation | |
| validate_button.click( | |
| fn=validate_api_key, | |
| inputs=[api_key_input], | |
| outputs=[api_key_status] | |
| ) | |
| # 2. Update Parameters UI when Model Changes | |
| model_dropdown.change( | |
| fn=update_parameter_visibility, | |
| inputs=[model_dropdown], | |
| outputs=list(param_elements.values()) # Pass the actual components | |
| ) | |
| # Trigger initial parameter visibility update on load | |
| demo.load( | |
| fn=update_parameter_visibility, | |
| inputs=[model_dropdown], | |
| outputs=list(param_elements.values()) | |
| ) | |
| # 3. Chat Submission Logic (using .then() for streaming if possible, or standard submit) | |
| # Note: Gradio streaming with gr.Chatbot often uses yields | |
| chat_submit_button.click( | |
| fn=handle_chat, | |
| inputs=[ | |
| api_key_input, | |
| model_dropdown, | |
| chat_history_state, | |
| chat_message_input, | |
| chat_file_upload | |
| ] + ordered_param_components, # Add dynamic params | |
| outputs=[chatbot_display, chat_message_input] # Update chatbot, clear input box | |
| ).then( | |
| # Update the state *after* the response is fully generated | |
| lambda history: history, # Simple pass-through to get final history | |
| inputs=chatbot_display, | |
| outputs=chat_history_state | |
| ) | |
| # Allow submitting chat by pressing Enter in the textbox | |
| chat_message_input.submit( | |
| fn=handle_chat, | |
| inputs=[ | |
| api_key_input, | |
| model_dropdown, | |
| chat_history_state, | |
| chat_message_input, | |
| chat_file_upload | |
| ] + ordered_param_components, | |
| outputs=[chatbot_display, chat_message_input] | |
| ).then( | |
| lambda history: history, | |
| inputs=chatbot_display, | |
| outputs=chat_history_state | |
| ) | |
| # 4. Clear Chat Logic | |
| def clear_chat_history_func(): | |
| return [], [] # Clears chatbot display and history state | |
| clear_chat_button.click( | |
| fn=clear_chat_history_func, | |
| inputs=[], | |
| outputs=[chatbot_display, chat_history_state] | |
| ) | |
| # 5. Single Response Submission Logic | |
| single_submit_button.click( | |
| fn=handle_single_response, | |
| inputs=[ | |
| api_key_input, | |
| model_dropdown, | |
| single_prompt_input, | |
| single_file_upload | |
| ] + ordered_param_components, # Add dynamic params | |
| outputs=[single_output_text, single_output_image] | |
| ) | |
| # Launch the Gradio app | |
| if __name__ == "__main__": | |
| demo.launch(debug=True) # Set debug=False for deployment |