Upload breed_visualization.py

breed_visualization.py

@@ -0,0 +1,570 @@
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+import sqlite3
+from matplotlib.figure import Figure
+from typing import Dict, List, Optional, Tuple
+import pandas as pd
+from PIL import Image
+
+def create_visualization_tab(dog_breeds, get_dog_description, calculate_compatibility_score, UserPreferences):
+    """Create a visualization tab for breed characteristic analysis"""
+    
+    # Create shared state container
+    shared_preferences = gr.State({
+        "living_space": "apartment",
+        "yard_access": "no_yard",
+        "exercise_time": 60,
+        "exercise_type": "moderate_activity",
+        "grooming_commitment": "medium",
+        "experience_level": "beginner",
+        "noise_tolerance": "medium",
+        "has_children": False,
+        "children_age": "school_age",
+        "climate": "moderate"
+    })
+    
+    gr.HTML("""
+        <div style='
+            text-align: center;
+            padding: 20px 0;
+            margin: 15px 0;
+            background: linear-gradient(to right, rgba(66, 153, 225, 0.1), rgba(72, 187, 120, 0.1));
+            border-radius: 10px;
+        '>
+            <p style='
+                font-size: 1.2em;
+                margin: 0;
+                padding: 0 20px;
+                line-height: 1.5;
+                background: linear-gradient(90deg, #4299e1, #48bb78);
+                -webkit-background-clip: text;
+                -webkit-text-fill-color: transparent;
+                font-weight: 600;
+            '>
+                Gain deeper insight into dog breed characteristics through visualization to help you make a more informed choice.
+            </p>
+        </div>
+    """)
+    
+    with gr.Tabs():
+        # Single breed radar chart analysis tab
+        with gr.TabItem("Breed Radar Chart Analysis"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    # User interface components - Left side
+                    breed_choices = [(breed.replace('_', ' '), breed) for breed in sorted(dog_breeds)]
+                    
+                    breed_dropdown = gr.Dropdown(
+                        label="Select Breed",
+                        choices=breed_choices,
+                        value=breed_choices[0][1] if breed_choices else None,
+                        info="Select a breed to view its characteristics radar chart"
+                    )
+                    
+                    with gr.Accordion("User Preferences (Affects Scoring)", open=False):
+                        living_space = gr.Radio(
+                            label="Living Space",
+                            choices=["apartment", "house_small", "house_large"],
+                            value="apartment",
+                            info="Your residential environment type"
+                        )
+                        
+                        yard_access = gr.Radio(
+                            label="Yard Condition",
+                            choices=["no_yard", "shared_yard", "private_yard"],
+                            value="no_yard",
+                            info="Whether you have yard space"
+                        )
+                        
+                        exercise_time = gr.Slider(
+                            label="Daily Exercise Time (minutes)",
+                            minimum=15,
+                            maximum=180,
+                            value=60,
+                            step=15,
+                            info="Daily exercise time you can provide"
+                        )
+                        
+                        exercise_type = gr.Radio(
+                            label="Exercise Type",
+                            choices=["light_walks", "moderate_activity", "active_training"],
+                            value="moderate_activity",
+                            info="Your preferred exercise method"
+                        )
+                        
+                        grooming_commitment = gr.Radio(
+                            label="Grooming Commitment",
+                            choices=["low", "medium", "high"],
+                            value="medium",
+                            info="Level of grooming care you're willing to provide"
+                        )
+                        
+                        experience_level = gr.Radio(
+                            label="Experience Level",
+                            choices=["beginner", "intermediate", "advanced"],
+                            value="beginner",
+                            info="Your level of dog owning experience"
+                        )
+                        
+                        noise_tolerance = gr.Radio(
+                            label="Noise Tolerance",
+                            choices=["low", "medium", "high"],
+                            value="medium",
+                            info="Your acceptance level of dog barking"
+                        )
+                        
+                        has_children = gr.Checkbox(
+                            label="Have Children",
+                            value=False,
+                            info="Whether you have children at home"
+                        )
+                        
+                        children_age = gr.Radio(
+                            label="Children's Age",
+                            choices=["toddler", "school_age", "teenager"],
+                            value="school_age",
+                            visible=False,
+                            info="Age group of children at home"
+                        )
+                        
+                        climate = gr.Radio(
+                            label="Climate Environment",
+                            choices=["cold", "moderate", "hot"],
+                            value="moderate",
+                            info="Climate characteristics of your living area"
+                        )
+                        
+                        # Listen for has_children changes to control children_age display
+                        has_children.change(
+                            fn=lambda x: gr.update(visible=x),
+                            inputs=has_children,
+                            outputs=children_age
+                        )
+                        
+                        # Add function to update shared preferences
+                        def update_shared_preferences(*args):
+                            return {
+                                "living_space": args[0],
+                                "yard_access": args[1],
+                                "exercise_time": args[2],
+                                "exercise_type": args[3],
+                                "grooming_commitment": args[4],
+                                "experience_level": args[5],
+                                "noise_tolerance": args[6],
+                                "has_children": args[7],
+                                "children_age": args[8],
+                                "climate": args[9]
+                            }
+                        
+                        # Monitor preference changes and update shared state
+                        all_preferences = [living_space, yard_access, exercise_time, 
+                                          exercise_type, grooming_commitment, experience_level, 
+                                          noise_tolerance, has_children, children_age, climate]
+                        
+                        for pref in all_preferences:
+                            pref.change(
+                                update_shared_preferences,
+                                inputs=all_preferences,
+                                outputs=shared_preferences
+                            )
+                    
+                    generate_btn = gr.Button("Generate Radar Chart", variant="primary")
+                
+                with gr.Column(scale=2):
+                    # Right display area
+                    radar_plot = gr.Plot(label="Breed Characteristics Radar Chart")
+                    breed_details = gr.JSON(label="Breed Detailed Information")
+            
+            # Button click event
+            generate_btn.click(
+                fn=lambda *args: generate_radar_chart(
+                    args[0], create_user_preferences(*args[1:]), 
+                    get_dog_description, calculate_compatibility_score
+                ),
+                inputs=[breed_dropdown, living_space, yard_access, exercise_time, 
+                       exercise_type, grooming_commitment, experience_level, 
+                       noise_tolerance, has_children, children_age, climate],
+                outputs=[radar_plot, breed_details]
+            )
+        
+        # Breed comparison analysis tab - Improved version
+        with gr.TabItem("Breed Comparison Analysis"):
+            with gr.Row():
+                breed1_dropdown = gr.Dropdown(
+                    label="Select First Breed",
+                    choices=breed_choices,
+                    value=breed_choices[0][1] if breed_choices else None
+                )
+                
+                breed2_dropdown = gr.Dropdown(
+                    label="Select Second Breed",
+                    choices=breed_choices,
+                    value=breed_choices[1][1] if len(breed_choices) > 1 else None
+                )
+            
+            with gr.Row():
+                use_shared_settings = gr.Checkbox(
+                    label="Use Radar Chart Analysis Settings",
+                    value=True,
+                    info="Check to use the same preferences from the Radar Chart Analysis tab"
+                )
+            
+            # Custom settings container - only visible when not using shared settings
+            with gr.Column(visible=False) as custom_settings:
+                with gr.Accordion("Custom Preferences", open=True):
+                    comp_living_space = gr.Radio(
+                        label="Living Space",
+                        choices=["apartment", "house_small", "house_large"],
+                        value="apartment"
+                    )
+                    
+                    comp_yard_access = gr.Radio(
+                        label="Yard Condition",
+                        choices=["no_yard", "shared_yard", "private_yard"],
+                        value="no_yard"
+                    )
+                    
+                    comp_exercise_time = gr.Slider(
+                        label="Daily Exercise Time (minutes)",
+                        minimum=15,
+                        maximum=180,
+                        value=60,
+                        step=15
+                    )
+                    
+                    comp_exercise_type = gr.Radio(
+                        label="Exercise Type",
+                        choices=["light_walks", "moderate_activity", "active_training"],
+                        value="moderate_activity"
+                    )
+            
+            # Toggle custom settings visibility based on checkbox
+            use_shared_settings.change(
+                fn=lambda x: gr.update(visible=not x),
+                inputs=use_shared_settings,
+                outputs=custom_settings
+            )
+            
+            compare_btn = gr.Button("Compare Breeds", variant="primary")
+            comparison_plot = gr.Plot(label="Breed Characteristics Comparison")
+            
+            # Improved comparison function that handles both shared and custom settings
+            def get_comparison_settings(use_shared, shared_prefs, *custom_prefs):
+                """
+                Select appropriate settings based on user choice
+                
+                Args:
+                    use_shared: Boolean indicating whether to use shared settings
+                    shared_prefs: Dictionary of shared preferences
+                    custom_prefs: Custom preference values if not using shared
+                    
+                Returns:
+                    UserPreferences object with the selected settings
+                """
+                if use_shared:
+                    # Use settings from Radar Chart tab
+                    return create_user_preferences_from_dict(shared_prefs)
+                else:
+                    # Use custom settings from Comparison tab
+                    return create_user_preferences(
+                        custom_prefs[0], custom_prefs[1], custom_prefs[2], custom_prefs[3],
+                        "medium", "beginner", "medium", False, "school_age", "moderate"
+                    )
+            
+            # Connect the comparison button
+            compare_btn.click(
+                fn=lambda breed1, breed2, use_shared, shared_prefs, *custom_prefs: generate_comparison_chart(
+                    breed1, breed2, 
+                    get_comparison_settings(use_shared, shared_prefs, *custom_prefs),
+                    get_dog_description, calculate_compatibility_score
+                ),
+                inputs=[
+                    breed1_dropdown, breed2_dropdown, 
+                    use_shared_settings, shared_preferences,
+                    comp_living_space, comp_yard_access, 
+                    comp_exercise_time, comp_exercise_type
+                ],
+                outputs=comparison_plot
+            )
+
+    return None
+
+def create_user_preferences(living_space, yard_access, exercise_time, exercise_type, 
+                          grooming_commitment, experience_level, noise_tolerance, 
+                          has_children, children_age, climate):
+    """
+    Create UserPreferences object from UI inputs
+    
+    Args:
+        living_space: Type of living environment
+        yard_access: Yard availability
+        exercise_time: Minutes of daily exercise
+        exercise_type: Type of exercise activity
+        grooming_commitment: Level of grooming commitment
+        experience_level: Dog owner experience level
+        noise_tolerance: Tolerance for barking
+        has_children: Whether there are children in the home
+        children_age: Age group of children
+        climate: Climate type of the living area
+        
+    Returns:
+        UserPreferences object with the specified settings
+    """
+    return UserPreferences(
+        living_space=living_space,
+        yard_access=yard_access,
+        exercise_time=exercise_time,
+        exercise_type=exercise_type,
+        grooming_commitment=grooming_commitment,
+        experience_level=experience_level,
+        time_availability="moderate",  # Default value
+        has_children=has_children,
+        children_age=children_age if has_children else "school_age",
+        noise_tolerance=noise_tolerance,
+        space_for_play=True,  # Default value
+        other_pets=False,  # Default value
+        climate=climate
+    )
+
+def create_user_preferences_from_dict(prefs_dict):
+    """
+    Create UserPreferences object from a dictionary
+    
+    Args:
+        prefs_dict: Dictionary containing preference values
+        
+    Returns:
+        UserPreferences object populated with the dictionary values
+    """
+    return UserPreferences(
+        living_space=prefs_dict["living_space"],
+        yard_access=prefs_dict["yard_access"],
+        exercise_time=prefs_dict["exercise_time"],
+        exercise_type=prefs_dict["exercise_type"],
+        grooming_commitment=prefs_dict["grooming_commitment"],
+        experience_level=prefs_dict["experience_level"],
+        time_availability="moderate",  # Default value
+        has_children=prefs_dict["has_children"],
+        children_age=prefs_dict["children_age"],
+        noise_tolerance=prefs_dict["noise_tolerance"],
+        space_for_play=True,  # Default value
+        other_pets=False,  # Default value
+        climate=prefs_dict["climate"]
+    )
+
+def generate_radar_chart(breed_name, user_prefs, get_dog_description, calculate_compatibility_score):
+    """
+    Generate radar chart for a single breed
+    
+    Args:
+        breed_name: Dog breed name
+        user_prefs: UserPreferences object
+        get_dog_description: Function to get breed description
+        calculate_compatibility_score: Function to calculate compatibility score
+    
+    Returns:
+        tuple: (matplotlib figure, breed description dict)
+    """
+    try:
+        # Get breed description
+        breed_info = get_dog_description(breed_name)
+        
+        if not breed_info:
+            # Create empty figure with error message
+            fig = Figure(figsize=(8, 8))
+            ax = fig.add_subplot(111)
+            ax.text(0.5, 0.5, f"No information found for breed: {breed_name}",
+                   horizontalalignment='center', verticalalignment='center', 
+                   transform=ax.transAxes, fontsize=14)
+            ax.axis('off')
+            return fig, {"error": f"No information found for breed: {breed_name}"}
+        
+        # Calculate compatibility scores
+        scores = calculate_compatibility_score(breed_info, user_prefs)
+        
+        # Prepare data for radar chart
+        categories = ['Space Compatibility', 'Exercise Needs', 'Grooming', 
+                     'Experience Required', 'Health', 'Noise Level']
+        values = [scores['space'], scores['exercise'], scores['grooming'], 
+                 scores['experience'], scores['health'], scores['noise']]
+        
+        # Close the polygon by appending first value
+        values_closed = values + [values[0]]
+        categories_closed = categories + [categories[0]]
+        
+        # Calculate angles for each category
+        angles = np.linspace(0, 2*np.pi, len(categories), endpoint=False).tolist()
+        angles += angles[:1]  # Close the loop
+        
+        # Create figure and polar axis
+        fig = Figure(figsize=(10, 8))
+        ax = fig.add_subplot(111, polar=True)
+        
+        # Plot data
+        ax.fill(angles, values_closed, color='skyblue', alpha=0.25)
+        ax.plot(angles, values_closed, color='blue', linewidth=2)
+        
+        # Add category labels
+        ax.set_xticks(angles[:-1])
+        ax.set_xticklabels(categories, fontsize=12)
+        
+        # Configure y-axis
+        ax.set_yticks([0.2, 0.4, 0.6, 0.8, 1.0])
+        ax.set_yticklabels(['0.2', '0.4', '0.6', '0.8', '1.0'], fontsize=10)
+        ax.set_ylim(0, 1)
+        
+        # Add a title
+        breed_display_name = breed_name.replace('_', ' ')
+        ax.set_title(f"{breed_display_name} Characteristic Scores", fontsize=16, pad=20)
+        
+        # Add value labels at each point
+        for i, (angle, value) in enumerate(zip(angles[:-1], values)):
+            ax.text(angle, value + 0.05, f"{value:.2f}", 
+                   ha='center', va='center', fontsize=10,
+                   bbox=dict(facecolor='white', alpha=0.7, boxstyle="round,pad=0.3"))
+        
+        # Add grid
+        ax.grid(True, linestyle='--', alpha=0.7)
+        
+        # Add overall score text
+        overall_score = scores.get('overall', 0)
+        fig.text(0.5, 0.02, f"Overall Match Score: {overall_score:.2f}", 
+                ha='center', fontsize=14, 
+                bbox=dict(facecolor='lightgreen', alpha=0.3, boxstyle="round,pad=0.5"))
+        
+        # Enhance aesthetics
+        fig.patch.set_facecolor('#f8f9fa')
+        ax.set_facecolor('#f0f0f0')
+        
+        # Print debug information
+        print(f"Generated radar chart for {breed_name}")
+        print(f"Scores: {scores}")
+        
+        return fig, breed_info
+    
+    except Exception as e:
+        # Create empty figure with error message
+        fig = Figure(figsize=(8, 8))
+        ax = fig.add_subplot(111)
+        ax.text(0.5, 0.5, f"Error generating chart: {str(e)}",
+               horizontalalignment='center', verticalalignment='center', 
+               transform=ax.transAxes, fontsize=14)
+        ax.axis('off')
+        print(f"Error in generate_radar_chart: {str(e)}")
+        return fig, {"error": f"Error generating chart: {str(e)}"}
+
+def generate_comparison_chart(breed1, breed2, user_prefs, get_dog_description, calculate_compatibility_score):
+    """
+    Generate comparison chart for two breeds
+    
+    Args:
+        breed1, breed2: Dog breed names
+        user_prefs: UserPreferences object
+        get_dog_description: Function to get breed description
+        calculate_compatibility_score: Function to calculate compatibility score
+    
+    Returns:
+        matplotlib figure: Comparison chart
+    """
+    try:
+        # Get breed descriptions
+        breed1_info = get_dog_description(breed1)
+        breed2_info = get_dog_description(breed2)
+        
+        if not breed1_info or not breed2_info:
+            # Create empty figure with error message
+            fig = Figure(figsize=(10, 6))
+            ax = fig.add_subplot(111)
+            ax.text(0.5, 0.5, f"Missing breed information. Please check both breeds.",
+                   horizontalalignment='center', verticalalignment='center', 
+                   transform=ax.transAxes, fontsize=14)
+            ax.axis('off')
+            return fig
+        
+        # Calculate compatibility scores
+        scores1 = calculate_compatibility_score(breed1_info, user_prefs)
+        scores2 = calculate_compatibility_score(breed2_info, user_prefs)
+        
+        # Prepare data for bar chart
+        categories = ['Space Compatibility', 'Exercise Needs', 'Grooming', 
+                     'Experience Required', 'Health', 'Noise Level']
+        values1 = [scores1['space'], scores1['exercise'], scores1['grooming'], 
+                  scores1['experience'], scores1['health'], scores1['noise']]
+        values2 = [scores2['space'], scores2['exercise'], scores2['grooming'], 
+                  scores2['experience'], scores2['health'], scores2['noise']]
+        
+        # Create figure
+        fig = Figure(figsize=(12, 7))
+        ax = fig.add_subplot(111)
+        
+        # Set width of bars
+        x = np.arange(len(categories))
+        width = 0.35
+        
+        # Plot bars
+        breed1_display = breed1.replace('_', ' ')
+        breed2_display = breed2.replace('_', ' ')
+        
+        rects1 = ax.bar(x - width/2, values1, width, label=breed1_display, color='#4299e1')
+        rects2 = ax.bar(x + width/2, values2, width, label=breed2_display, color='#f56565')
+        
+        # Add labels and title
+        ax.set_xlabel('Scoring Dimensions', fontsize=12)
+        ax.set_ylabel('Score (0-1)', fontsize=12)
+        ax.set_title(f'{breed1_display} vs {breed2_display} Breed Comparison', fontsize=15)
+        ax.set_xticks(x)
+        ax.set_xticklabels(categories, rotation=30, ha='right')
+        ax.legend(loc='upper right')
+        
+        # Add value labels on top of bars
+        def add_labels(rects):
+            for rect in rects:
+                height = rect.get_height()
+                ax.annotate(f'{height:.2f}',
+                            xy=(rect.get_x() + rect.get_width() / 2, height),
+                            xytext=(0, 3),  # 3 points vertical offset
+                            textcoords="offset points",
+                            ha='center', va='bottom',
+                            fontsize=9, fontweight='bold')
+        
+        add_labels(rects1)
+        add_labels(rects2)
+        
+        # Set y-axis limit
+        ax.set_ylim(0, 1.1)
+        
+        # Add grid
+        ax.grid(True, linestyle='--', alpha=0.3, axis='y')
+        
+        # Add overall score comparison
+        overall1 = scores1.get('overall', 0)
+        overall2 = scores2.get('overall', 0)
+        
+        fig.text(0.5, 0.02, 
+                f"Overall Match Scores:  {breed1_display}: {overall1:.2f}  |  {breed2_display}: {overall2:.2f}", 
+                ha='center', fontsize=13, 
+                bbox=dict(facecolor='#edf2f7', alpha=0.7, boxstyle="round,pad=0.5"))
+        
+        # Enhance aesthetics
+        fig.patch.set_facecolor('#f8f9fa')
+        ax.set_facecolor('#f0f0f0')
+        
+        # Add a tight layout to ensure everything fits
+        fig.tight_layout(rect=[0, 0.05, 1, 0.95])
+        
+        # Print debug information
+        print(f"Generated comparison chart for {breed1} vs {breed2}")
+        
+        return fig
+    
+    except Exception as e:
+        # Create empty figure with error message
+        fig = Figure(figsize=(10, 6))
+        ax = fig.add_subplot(111)
+        ax.text(0.5, 0.5, f"Error generating comparison: {str(e)}",
+               horizontalalignment='center', verticalalignment='center', 
+               transform=ax.transAxes, fontsize=14)
+        ax.axis('off')
+        print(f"Error in generate_comparison_chart: {str(e)}")
+        return fig