Please enter an API Key.
" 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 "API Key seems valid (can list models).
" else: return "API Key is valid but might not have access to the required Gemini models.
" 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 "API Key is invalid.
" else: return f"API Key validation failed. Error: {str(e)}
" 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("Enter your key and click Validate.
") # 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