Update app.py

app.py

@@ -164,15 +164,14 @@ def encode_image_to_base64(image_path):
                 elif file_extension == "webp":
                     mime_type = "image/webp"
                 return f"data:{mime_type};base64,{encoded_string}"
-        else:  # Pillow Image or file-like object
-            if Image is not None:
-                buffered = io.BytesIO()
-                image_path.save(buffered, format="PNG")
-                encoded_string = base64.b64encode(buffered.getvalue()).decode('utf-8')
-                return f"data:image/png;base64,{encoded_string}"
-            else:
-                logger.error("PIL is not installed, cannot process image object")
-                return None
+        elif Image is not None and hasattr(image_path, 'save'):  # Pillow Image
+            buffered = io.BytesIO()
+            image_path.save(buffered, format="PNG")
+            encoded_string = base64.b64encode(buffered.getvalue()).decode('utf-8')
+            return f"data:image/png;base64,{encoded_string}"
+        else:  # Handle file object or other types
+            logger.error(f"Unsupported image type: {type(image_path)}")
+            return None
     except Exception as e:
         logger.error(f"Error encoding image: {str(e)}")
         return None
@@ -258,40 +257,13 @@ def prepare_message_with_media(text, images=None, documents=None):
     
     return content
 
-def filter_models(search_term):
-    """Filter models based on search term"""
-    if not search_term:
-        return gr.Dropdown.update(choices=[model[0] for model in ALL_MODELS], value=ALL_MODELS[0][0])
-    
-    filtered_models = [model[0] for model in ALL_MODELS if search_term.lower() in model[0].lower()]
-    
-    if filtered_models:
-        return gr.Dropdown.update(choices=filtered_models, value=filtered_models[0])
-    else:
-        return gr.Dropdown.update(choices=[model[0] for model in ALL_MODELS], value=ALL_MODELS[0][0])
-
-def get_model_info(model_name):
-    """Get model information by name"""
-    for model in ALL_MODELS:
-        if model[0] == model_name:
-            return model
-    return None
-
-def update_context_display(model_name):
-    """Update the context size display based on the selected model"""
-    model_info = get_model_info(model_name)
-    if model_info:
-        name, model_id, context_size = model_info
-        context_formatted = f"{context_size:,}"
-        return f"{context_formatted} tokens"
-    return "Unknown"
-
-def update_category_models(category):
-    """Update models list when category changes"""
-    for cat in MODELS:
-        if cat["category"] == category:
-            return gr.Radio.update(choices=[model[0] for model in cat["models"]], value=cat["models"][0][0])
-    return gr.Radio.update(choices=[], value=None)
+def process_uploaded_images(files):
+    """Process uploaded image files - fixed for Gradio 4.44.1"""
+    file_paths = []
+    for file in files:
+        if hasattr(file, 'name'):
+            file_paths.append(file.name)
+    return file_paths
 
 def ask_ai(message, chatbot, model_choice, temperature, max_tokens, top_p, 
            frequency_penalty, presence_penalty, repetition_penalty, top_k, 
@@ -428,10 +400,6 @@ def ask_ai(message, chatbot, model_choice, temperature, max_tokens, top_p,
     
     return chatbot, ""
 
-def process_uploaded_images(files):
-    """Process uploaded image files"""
-    return [file.name for file in files]
-
 def clear_chat():
     """Reset all inputs"""
     return [], "", [], [], 0.7, 1000, 0.8, 0.0, 0.0, 1.0, 40, 0.1, 0, 0.0, False, "default", "none", "", []
@@ -465,7 +433,7 @@ def create_app():
         }
     """) as demo:
         gr.Markdown("""
-        # CrispChat
+        # Enhanced AI Chat
         
         Chat with various AI models from OpenRouter with support for images and documents.
         """)
@@ -545,15 +513,16 @@ def create_app():
                     
                     # Model category selection
                     with gr.Accordion("Browse by Category", open=False):
-                        model_categories = gr.Radio(
+                        model_categories = gr.Dropdown(
                             [category["category"] for category in MODELS],
                             label="Categories",
                             value=MODELS[0]["category"]
                         )
                         
-                        category_models = gr.Radio(
+                        category_models = gr.Dropdown(
                             [model[0] for model in MODELS[0]["models"]],
-                            label="Models in Category"
+                            label="Models in Category",
+                            value=MODELS[0]["models"][0][0]
                         )
                 
                 with gr.Accordion("Generation Parameters", open=False):
@@ -719,60 +688,90 @@ def create_app():
         Built with ❤️ using Gradio and OpenRouter API | Context sizes shown next to model names
         """)
 
+        # Helper function to filter models
+        def filter_models(search_term):
+            if not search_term:
+                return [model[0] for model in ALL_MODELS], ALL_MODELS[0][0]
+            
+            filtered_models = [model[0] for model in ALL_MODELS if search_term.lower() in model[0].lower()]
+            
+            if filtered_models:
+                return filtered_models, filtered_models[0]
+            else:
+                return [model[0] for model in ALL_MODELS], ALL_MODELS[0][0]
+
+        # Helper function for context display
+        def update_context_display(model_name):
+            for model in ALL_MODELS:
+                if model[0] == model_name:
+                    _, _, context_size = model
+                    context_formatted = f"{context_size:,}"
+                    return f"{context_formatted} tokens"
+            return "Unknown"
+
+        # Helper function for model info display
+        def update_model_info(model_name):
+            for model in ALL_MODELS:
+                if model[0] == model_name:
+                    name, model_id, context_size = model
+                    return f"""
+                    <div class="model-info">
+                        <h3>{name}</h3>
+                        <p><strong>Model ID:</strong> {model_id}</p>
+                        <p><strong>Context Size:</strong> {context_size:,} tokens</p>
+                        <p><strong>Provider:</strong> {model_id.split('/')[0]}</p>
+                    </div>
+                    """
+            return "<p>Model information not available</p>"
+        
+        # Helper function to update category models
+        def update_category_models(category):
+            for cat in MODELS:
+                if cat["category"] == category:
+                    model_names = [model[0] for model in cat["models"]]
+                    return model_names, model_names[0]
+            return [], ""
+
         # Connect model search to dropdown filter
         model_search.change(
             fn=filter_models,
-            inputs=[model_search],
-            outputs=[model_choice]
+            inputs=model_search,
+            outputs=[model_choice, model_choice]
         )
         
         # Update context display when model changes
         model_choice.change(
             fn=update_context_display,
-            inputs=[model_choice],
-            outputs=[context_display]
+            inputs=model_choice,
+            outputs=context_display
+        )
+        
+        # Update model info when model changes
+        model_choice.change(
+            fn=update_model_info,
+            inputs=model_choice,
+            outputs=model_info_display
         )
         
         # Update model list when category changes
         model_categories.change(
             fn=update_category_models,
-            inputs=[model_categories],
-            outputs=[category_models]
+            inputs=model_categories,
+            outputs=[category_models, category_models]
         )
         
         # Update main model choice when category model is selected
         category_models.change(
             fn=lambda x: x,
-            inputs=[category_models],
-            outputs=[model_choice]
+            inputs=category_models,
+            outputs=model_choice
         )
         
         # Process uploaded images
         image_upload_btn.upload(
             fn=process_uploaded_images,
-            inputs=[image_upload_btn],
-            outputs=[images]
-        )
-        
-        # Update model info when model changes
-        def update_model_info(model_name):
-            model_info = get_model_info(model_name)
-            if model_info:
-                name, model_id, context_size = model_info
-                return f"""
-                <div class="model-info">
-                    <h3>{name}</h3>
-                    <p><strong>Model ID:</strong> {model_id}</p>
-                    <p><strong>Context Size:</strong> {context_size:,} tokens</p>
-                    <p><strong>Provider:</strong> {model_id.split('/')[0]}</p>
-                </div>
-                """
-            return "<p>Model information not available</p>"
-        
-        model_choice.change(
-            fn=update_model_info,
-            inputs=[model_choice],
-            outputs=[model_info_display]
+            inputs=image_upload_btn,
+            outputs=images
         )
         
         # Set up events for the submit button