Upload 6 files

breed_comparison.py

@@ -0,0 +1,559 @@
+
+import gradio as gr
+import sqlite3
+from dog_database import get_dog_description
+from breed_health_info import breed_health_info
+from breed_noise_info import breed_noise_info
+
+def create_comparison_tab(dog_breeds, get_dog_description, breed_noise_info, breed_health_info):
+    with gr.TabItem("Breed Comparison"):
+        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;
+                '>
+                    Select two dog breeds to compare their characteristics and care requirements.
+                </p>
+            </div>
+        """)
+
+        with gr.Row():
+            breed1_dropdown = gr.Dropdown(
+                choices=dog_breeds,
+                label="Select First Breed",
+                value="Golden_Retriever"
+            )
+            breed2_dropdown = gr.Dropdown(
+                choices=dog_breeds,
+                label="Select Second Breed",
+                value="Border_Collie"
+            )
+
+        compare_btn = gr.Button("Compare Breeds")
+        comparison_output = gr.HTML(label="Comparison Results")
+
+        def format_noise_data(notes):
+            characteristics = []
+            triggers = []
+            noise_level = "Moderate"  # 預設值
+
+            if isinstance(notes, str):
+                lines = notes.strip().split('\n')
+                section = ""
+                for line in lines:
+                    line = line.strip()
+                    if "Typical noise characteristics:" in line:
+                        section = "characteristics"
+                    elif "Barking triggers:" in line:
+                        section = "triggers"
+                    elif "Noise level:" in line:
+                        noise_level = line.split(':')[1].strip()
+                    elif line.startswith('•'):
+                        if section == "characteristics":
+                            characteristics.append(line[1:].strip())
+                        elif section == "triggers":
+                            triggers.append(line[1:].strip())
+
+            return {
+                'characteristics': characteristics,
+                'triggers': triggers,
+                'noise_level': noise_level
+            }
+
+        def format_health_data(notes):
+            considerations = []
+            screenings = []
+
+            if isinstance(notes, str):
+                lines = notes.strip().split('\n')
+                current_section = None
+
+                for line in lines:
+                    line = line.strip()
+                    # 修正字串比對
+                    if "Common breed-specific health considerations" in line:
+                        current_section = "considerations"
+                    elif "Recommended health screenings:" in line:
+                        current_section = "screenings"
+                    elif line.startswith('•'):
+                        item = line[1:].strip()
+                        if current_section == "considerations":
+                            considerations.append(item)
+                        elif current_section == "screenings":
+                            screenings.append(item)
+
+            # 只有當真的沒有資料時才返回 "Information not available"
+            if not considerations and not screenings:
+                return {
+                    'considerations': ["Information not available"],
+                    'screenings': ["Information not available"]
+                }
+
+            return {
+                'considerations': considerations,
+                'screenings': screenings
+            }
+
+        def get_comparison_styles():
+            return """
+            .comparison-container {
+                display: grid;
+                grid-template-columns: 1fr 1fr;
+                gap: 24px;
+                padding: 20px;
+            }
+
+            .breed-column {
+                background: white;
+                border-radius: 10px;
+                padding: 24px;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            }
+
+            .section-title {
+                font-size: 24px;
+                color: #2D3748;
+                margin-bottom: 20px;
+                padding-bottom: 10px;
+                border-bottom: 2px solid #E2E8F0;
+            }
+
+            .info-section {
+                display: grid;
+                grid-template-columns: repeat(2, 1fr);
+                gap: 16px;
+                margin-bottom: 24px;
+            }
+
+            .info-item {
+                position: relative;
+                background: #F8FAFC;
+                padding: 16px;
+                border-radius: 8px;
+                border: 1px solid #E2E8F0;
+            }
+
+            .info-label {
+                display: flex;
+                align-items: center;
+                gap: 8px;
+                color: #4A5568;
+                font-size: 0.9em;
+                margin-bottom: 4px;
+            }
+
+            .info-icon {
+                cursor: help;
+                background: #E2E8F0;
+                width: 18px;
+                height: 18px;
+                border-radius: 50%;
+                display: inline-flex;
+                align-items: center;
+                justify-content: center;
+                font-size: 12px;
+                color: #4A5568;
+                margin-left: 4px;
+            }
+
+            .info-icon:hover + .tooltip-content {
+                display: block;
+            }
+
+            .tooltip-content {
+                display: none;
+                position: absolute;
+                background: #2D3748;
+                color: #FFFFFF;
+                padding: 8px 12px;
+                border-radius: 6px;
+                font-size: 14px;
+                line-height: 1.3;
+                width: max-content;
+                max-width: 280px;
+                z-index: 1000;
+                top: 0;           /* 修改位置 */
+                left: 100%;
+                margin-left: 10px;
+                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                white-space: normal;  /* 允許文字換行 */
+            }
+
+
+            .tooltip-content,
+            .tooltip-content *,
+            .tooltip-content strong,
+            .tooltip-content li,
+            .tooltip-content ul,
+            .tooltip-content p,
+            .tooltip-content span,
+            .tooltip-content div {
+                color: #FFFFFF !important;
+            }
+
+
+            .tooltip-content::before {
+                content: '';
+                position: absolute;
+                left: -6px;
+                top: 14px;        /* 配合上方位置調整 */
+                border-width: 6px;
+                border-style: solid;
+                border-color: transparent #2D3748 transparent transparent;
+            }
+
+            .tooltip-content strong {
+                color: #FFFFFF;
+                display: block;
+                margin-bottom: 4px;
+                font-weight: 600;
+            }
+
+            .tooltip-content ul {
+                margin: 0;
+                padding-left: 16px;
+                color: #FFFFFF;
+            }
+
+            .tooltip-content * {
+                color: #FFFFFF;
+            }
+
+            .tooltip-content li {
+                margin-bottom: 2px;
+                color: #FFFFFF;
+            }
+
+            .tooltip-content li::before {
+                color: #FFFFFF !important;
+            }
+
+            .tooltip-content br {
+                display: block;
+                margin: 2px 0;
+            }
+
+            .info-value {
+                color: #2D3748;
+                font-weight: 500;
+            }
+
+            .characteristic-section {
+                background: #F8FAFC;
+                padding: 20px;
+                border-radius: 8px;
+                margin-bottom: 20px;
+            }
+
+            .subsection-title {
+                font-size: 18px;
+                color: #2D3748;
+                margin-bottom: 16px;
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+
+            .noise-level {
+                background: #EDF2F7;
+                padding: 16px;
+                border-radius: 6px;
+                margin: 16px 0;
+                border: 1px solid #CBD5E0;
+            }
+
+            .level-label {
+                color: #4A5568;
+                font-size: 1.1em;
+                font-weight: 500;
+                margin-bottom: 8px;
+            }
+
+            .level-value {
+                color: #2D3748;
+                font-size: 1.2em;
+                font-weight: 600;
+            }
+
+            .characteristics-grid {
+                display: grid;
+                grid-template-columns: repeat(2, 1fr);
+                gap: 12px;
+                margin-top: 12px;
+            }
+
+            .characteristic-item {
+                background: white;
+                padding: 12px;
+                border-radius: 6px;
+                border: 1px solid #E2E8F0;
+                color: #4A5568;
+            }
+
+            .health-insights {
+                margin-top: 24px;
+            }
+
+            .health-grid {
+                display: grid;
+                grid-template-columns: 1fr;
+                gap: 8px;
+            }
+
+            .health-item {
+                background: white;
+                padding: 12px;
+                border-radius: 6px;
+                border: 1px solid #E2E8F0;
+                color: #E53E3E;
+            }
+
+            .screening-item {
+                background: white;
+                padding: 12px;
+                border-radius: 6px;
+                border: 1px solid #E2E8F0;
+                color: #38A169;
+            }
+
+            .learn-more-btn {
+                display: inline-block;
+                margin-top: 20px;
+                padding: 12px 24px;
+                background: linear-gradient(135deg, #2B6CB0, #2C5282);
+                color: white;
+                text-decoration: none;
+                border-radius: 6px;
+                transition: all 0.3s ease;
+                text-align: center;
+                width: 100%;
+                font-weight: 500;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            }
+
+            .learn-more-btn:hover {
+                background: linear-gradient(135deg, #2C5282, #2B6CB0);
+                transform: translateY(-2px);
+                box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            }
+
+            .info-disclaimer {
+                margin-top: 24px;
+                padding: 16px;
+                background: #F7FAFC;
+                border-radius: 8px;
+                font-size: 0.9em;
+                color: #4A5568;
+                line-height: 1.5;
+                border-left: 4px solid #4299E1;
+            }
+
+            @media (max-width: 768px) {
+                .comparison-container {
+                    grid-template-columns: 1fr;
+                }
+                .info-section {
+                    grid-template-columns: 1fr;
+                }
+                .characteristics-grid {
+                    grid-template-columns: 1fr;
+                }
+            }
+            """
+
+        def show_comparison(breed1, breed2):
+            if not breed1 or not breed2:
+                return "Please select two breeds to compare"
+
+            breed1_info = get_dog_description(breed1)
+            breed2_info = get_dog_description(breed2)
+            breed1_noise = breed_noise_info.get(breed1, {})
+            breed2_noise = breed_noise_info.get(breed2, {})
+            breed1_health = breed_health_info.get(breed1, {})
+            breed2_health = breed_health_info.get(breed2, {})
+
+            def create_info_item(label, value, tooltip_text=""):
+                tooltip = f"""
+                    <div class="info-label">
+                        <span>{label}</span>
+                        <div class="tooltip">
+                            <span class="info-icon">i</span>
+                            <div class="tooltip-content">
+                                {tooltip_text}
+                            </div>
+                        </div>
+                    </div>
+                """ if tooltip_text else f'<div class="info-label">{label}</div>'
+
+                return f"""
+                <div class="info-item" style="position: relative;">
+                    {tooltip}
+                    <div class="info-value">{value}</div>
+                </div>
+                """
+
+            def create_breed_section(breed, info, noise_info, health_info):
+                # 建立提示文字
+                section_tooltips = {
+                    'Size': """
+                        <strong>Size Categories:</strong><br>
+                        • Small: Under 20 pounds<br>
+                        • Medium: 20-60 pounds<br>
+                        • Large: Over 60 pounds
+                    """,
+                    'Exercise': """
+                        <strong>Exercise Needs:</strong><br>
+                        • Low: Short walks suffice<br>
+                        • Moderate: 1-2 hours daily<br>
+                        • High: 2+ hours daily activity<br>
+                        • Very High: Intensive daily exercise
+                    """,
+                    'Grooming': """
+                        <strong>Grooming Requirements:</strong><br>
+                        • Low: Occasional brushing<br>
+                        • Moderate: Weekly grooming<br>
+                        • High: Daily maintenance needed
+                    """,
+                    'Children': """
+                        <strong>Compatibility with Children:</strong><br>
+                        • Yes: Excellent with kids<br>
+                        • Moderate: Good with supervision<br>
+                        • No: Better with older children
+                    """,
+                    'Lifespan': """
+                        <strong>Average Lifespan Range:</strong><br>
+                        Typical lifespan for this breed with proper care and genetics
+                    """,
+                    'noise': """
+                        <strong>Noise Behavior Information:</strong><br>
+                        • Noise Level indicates typical vocalization intensity<br>
+                        • Characteristics describe common vocal behaviors<br>
+                        • Triggers list common causes of barking or vocalization
+                    """,
+                    'health': """
+                        <strong>Health Information:</strong><br>
+                        • Health considerations are breed-specific concerns<br>
+                        • Screenings are recommended preventive tests<br>
+                        • Always consult with veterinary professionals
+                    """
+                }
+
+                noise_data = format_noise_data(noise_info.get('noise_notes', ''))
+                health_data = format_health_data(health_info.get('health_notes', ''))
+
+                def create_section_header(title, icon, tooltip_text):
+                    return f"""
+                    <div class="section-header">
+                        <span>{icon}</span>
+                        <span>{title}</span>
+                        <span class="tooltip">
+                            <span class="tooltip-icon">ⓘ</span>
+                            <span class="tooltip-text">{tooltip_text}</span>
+                        </span>
+                    </div>
+                    """
+
+                return f"""
+                <div class="breed-column">
+                    <h2 class="section-title">🐕 {breed.replace('_', ' ')}</h2>
+
+                    <div class="info-section">
+                        {create_info_item('Size', info['Size'], section_tooltips['Size'])}
+                        {create_info_item('Exercise', info['Exercise Needs'], section_tooltips['Exercise'])}
+                        {create_info_item('Grooming', info['Grooming Needs'], section_tooltips['Grooming'])}
+                        {create_info_item('With Children', info['Good with Children'], section_tooltips['Children'])}
+                        {create_info_item('Lifespan', info['Lifespan'], section_tooltips['Lifespan'])}
+                    </div>
+
+                    <div class="characteristic-section">
+                        {create_section_header('Noise Behavior', '🔊', section_tooltips['noise'])}
+                        <div class="noise-level">
+                            <div class="level-label">Noise Level</div>
+                            <div class="level-value">{noise_data['noise_level'].upper()}</div>
+                        </div>
+
+                        <div class="subsection">
+                            <h4>Typical Characteristics</h4>
+                            <div class="characteristics-grid">
+                                {' '.join([f'<div class="characteristic-item">{char}</div>'
+                                        for char in noise_data['characteristics']])}
+                            </div>
+                        </div>
+
+                        <div class="subsection">
+                            <h4>Barking Triggers</h4>
+                            <div class="characteristics-grid">
+                                {' '.join([f'<div class="characteristic-item">{trigger}</div>'
+                                        for trigger in noise_data['triggers']])}
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="characteristic-section health-insights">
+                        {create_section_header('Health Insights', '🏥', section_tooltips['health'])}
+                        <div class="subsection">
+                            <h4>Health Considerations</h4>
+                            <div class="health-grid">
+                                {' '.join([f'<div class="health-item">{item}</div>'
+                                        for item in health_data['considerations']])}
+                            </div>
+                        </div>
+
+                        <div class="subsection">
+                            <h4>Recommended Screenings</h4>
+                            <div class="health-grid">
+                                {' '.join([f'<div class="screening-item">{item}</div>'
+                                        for item in health_data['screenings']])}
+                            </div>
+                        </div>
+                    </div>
+
+                    <a href="https://www.akc.org/dog-breeds/{breed.lower().replace('_', '-')}/"
+                    class="learn-more-btn"
+                    target="_blank">
+                        🌐 Learn more about {breed.replace('_', ' ')} on AKC
+                    </a>
+                </div>
+                """
+
+            html_output = f"""
+            <div class="comparison-container">
+                {create_breed_section(breed1, breed1_info, breed1_noise, breed1_health)}
+                {create_breed_section(breed2, breed2_info, breed2_noise, breed2_health)}
+            </div>
+            <div class="info-disclaimer">
+                <strong>Note:</strong> The health and behavioral information provided is for general reference only.
+                Individual dogs may vary, and characteristics can be influenced by training, socialization, and genetics.
+                Always consult with veterinary professionals for specific health advice and professional trainers for
+                behavioral guidance.
+            </div>
+            <style>{get_comparison_styles()}</style>
+            """
+
+            return html_output
+
+        compare_btn.click(
+            show_comparison,
+            inputs=[breed1_dropdown, breed2_dropdown],
+            outputs=comparison_output
+        )
+
+    return {
+        'breed1_dropdown': breed1_dropdown,
+        'breed2_dropdown': breed2_dropdown,
+        'compare_btn': compare_btn,
+        'comparison_output': comparison_output
+    }

breed_detection.py

@@ -0,0 +1,61 @@
+import re
+import gradio as gr
+from PIL import Image
+
+def create_detection_tab(predict_fn, example_images):
+    with gr.TabItem("Breed Detection"):
+        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;
+                '>
+                    Upload a picture of a dog, and the model will predict its breed and provide detailed information!
+                </p>
+                <p style='
+                    font-size: 0.9em;
+                    color: #666;
+                    margin-top: 8px;
+                    padding: 0 20px;
+                '>
+                    Note: The model's predictions may not always be 100% accurate, and it is recommended to use the results as a reference.
+                </p>
+            </div>
+        """)
+        
+        with gr.Row():
+            input_image = gr.Image(label="Upload a dog image", type="pil")
+            output_image = gr.Image(label="Annotated Image")
+
+        output = gr.HTML(label="Prediction Results")
+        initial_state = gr.State()
+
+        input_image.change(
+            predict_fn,
+            inputs=input_image,
+            outputs=[output, output_image, initial_state]
+        )
+
+        gr.Examples(
+            examples=example_images,
+            inputs=input_image
+        )
+
+    return {
+        'input_image': input_image,
+        'output_image': output_image,
+        'output': output,
+        'initial_state': initial_state
+    }

breed_recommendation.py

@@ -0,0 +1,292 @@
+
+import sqlite3
+import gradio as gr
+from dog_database import get_dog_description, dog_data
+from breed_health_info import breed_health_info
+from breed_noise_info import breed_noise_info
+from scoring_calculation_system import UserPreferences, calculate_compatibility_score
+from recommendation_html_format import format_recommendation_html, get_breed_recommendations
+from smart_breed_matcher import SmartBreedMatcher
+from description_search_ui import create_description_search_tab
+
+def create_recommendation_tab(UserPreferences, get_breed_recommendations, format_recommendation_html, history_component):
+
+    with gr.TabItem("Breed Recommendation"):
+        with gr.Tabs():
+            with gr.Tab("Find by Criteria"):
+                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;
+                        '>
+                            Tell us about your lifestyle, and we'll recommend the perfect dog breeds for you!
+                        </p>
+                    </div>
+                """)
+
+                with gr.Row():
+                    with gr.Column():
+                        living_space = gr.Radio(
+                            choices=["apartment", "house_small", "house_large"],
+                            label="What type of living space do you have?",
+                            info="Choose your current living situation",
+                            value="apartment"
+                        )
+
+                        exercise_time = gr.Slider(
+                            minimum=0,
+                            maximum=180,
+                            value=60,
+                            label="Daily exercise time (minutes)",
+                            info="Consider walks, play time, and training"
+                        )
+
+                        grooming_commitment = gr.Radio(
+                            choices=["low", "medium", "high"],
+                            label="Grooming commitment level",
+                            info="Low: monthly, Medium: weekly, High: daily",
+                            value="medium"
+                        )
+
+                    with gr.Column():
+                        experience_level = gr.Radio(
+                            choices=["beginner", "intermediate", "advanced"],
+                            label="Dog ownership experience",
+                            info="Be honest - this helps find the right match",
+                            value="beginner"
+                        )
+
+                        has_children = gr.Checkbox(
+                            label="Have children at home",
+                            info="Helps recommend child-friendly breeds"
+                        )
+
+                        noise_tolerance = gr.Radio(
+                            choices=["low", "medium", "high"],
+                            label="Noise tolerance level",
+                            info="Some breeds are more vocal than others",
+                            value="medium"
+                        )
+
+                get_recommendations_btn = gr.Button("Find My Perfect Match! 🔍", variant="primary")
+                recommendation_output = gr.HTML(label="Breed Recommendations")
+
+            with gr.Tab("Find by Description"):
+                description_input, description_search_btn, description_output, loading_msg = create_description_search_tab()
+
+    
+        def on_find_match_click(*args):
+            try:
+                user_prefs = UserPreferences(
+                    living_space=args[0],
+                    exercise_time=args[1],
+                    grooming_commitment=args[2],
+                    experience_level=args[3],
+                    has_children=args[4],
+                    noise_tolerance=args[5],
+                    space_for_play=True if args[0] != "apartment" else False,
+                    other_pets=False,
+                    climate="moderate",
+                    health_sensitivity="medium",  # 新增: 默認中等敏感度
+                    barking_acceptance=args[5]    # 使用 noise_tolerance 作為 barking_acceptance
+                )
+
+                recommendations = get_breed_recommendations(user_prefs, top_n=10)
+
+                history_results = [{
+                    'breed': rec['breed'],
+                    'rank': rec['rank'],
+                    'overall_score': rec['final_score'],
+                    'base_score': rec['base_score'],
+                    'bonus_score': rec['bonus_score'],
+                    'scores': rec['scores']
+                } for rec in recommendations]
+
+                # 保存到歷史記錄，也需要更新保存的偏好設定
+                history_component.save_search(
+                    user_preferences={
+                        'living_space': args[0],
+                        'exercise_time': args[1],
+                        'grooming_commitment': args[2],
+                        'experience_level': args[3],
+                        'has_children': args[4],
+                        'noise_tolerance': args[5],
+                        'health_sensitivity': "medium",
+                        'barking_acceptance': args[5]
+                    },
+                    results=history_results
+                )
+
+                return format_recommendation_html(recommendations)
+
+            except Exception as e:
+                print(f"Error in find match: {str(e)}")
+                import traceback
+                print(traceback.format_exc())
+                return "Error getting recommendations"
+
+        def on_description_search(description: str):
+            try:
+                matcher = SmartBreedMatcher(dog_data)
+                breed_recommendations = matcher.match_user_preference(description, top_n=10)
+                
+                print("Creating user preferences...")
+                user_prefs = UserPreferences(
+                    living_space="apartment" if "apartment" in description.lower() else "house_small",
+                    exercise_time=60,
+                    grooming_commitment="medium",
+                    experience_level="intermediate",
+                    has_children="children" in description.lower() or "kids" in description.lower(),
+                    noise_tolerance="medium",
+                    space_for_play=True if "yard" in description.lower() or "garden" in description.lower() else False,
+                    other_pets=False,
+                    climate="moderate",
+                    health_sensitivity="medium",
+                    barking_acceptance=None
+                )
+
+                final_recommendations = []
+                
+                for smart_rec in breed_recommendations:
+                    breed_name = smart_rec['breed']
+                    breed_info = get_dog_description(breed_name)
+                    if not isinstance(breed_info, dict):
+                        continue
+                        
+                    # 計算基礎相容性分數
+                    compatibility_scores = calculate_compatibility_score(breed_info, user_prefs)
+
+                    bonus_reasons = []
+                    bonus_score = 0
+                    is_preferred = smart_rec.get('is_preferred', False)
+                    similarity = smart_rec.get('similarity', 0)
+        
+                    # 用戶直接提到的品種
+                    if is_preferred:
+                        bonus_score = 0.15  # 15% bonus
+                        bonus_reasons.append("Directly mentioned breed (+15%)")
+                    # 高相似度品種
+                    elif similarity > 0.8:
+                        bonus_score = 0.10  # 10% bonus
+                        bonus_reasons.append("Very similar to preferred breed (+10%)")
+                    # 中等相似度品種
+                    elif similarity > 0.6:
+                        bonus_score = 0.05  # 5% bonus
+                        bonus_reasons.append("Similar to preferred breed (+5%)")
+        
+                    # 基於品種特性的額外加分
+                    temperament = breed_info.get('Temperament', '').lower()
+                    if any(trait in temperament for trait in ['friendly', 'gentle', 'affectionate']):
+                        bonus_score += 0.02  # 2% bonus
+                        bonus_reasons.append("Positive temperament traits (+2%)")
+                    
+                    if breed_info.get('Good with Children') == 'Yes' and user_prefs.has_children:
+                        bonus_score += 0.03  # 3% bonus
+                        bonus_reasons.append("Excellent with children (+3%)")
+        
+                    # 基礎分數和最終分數計算
+                    base_score = compatibility_scores.get('overall', 0.7)
+                    final_score = min(0.95, base_score + bonus_score)  # 確保不超過95%
+                    
+                    final_recommendations.append({
+                        'rank': 0,
+                        'breed': breed_name,
+                        'base_score': round(base_score, 4),
+                        'bonus_score': round(bonus_score, 4),
+                        'final_score': round(final_score, 4),
+                        'scores': compatibility_scores,
+                        'match_reason': ' • '.join(bonus_reasons) if bonus_reasons else "Standard match",
+                        'info': breed_info,
+                        'noise_info': breed_noise_info.get(breed_name, {}),
+                        'health_info': breed_health_info.get(breed_name, {})
+                    })
+                
+                # 根據最終分數排序
+                final_recommendations.sort(key=lambda x: (-x['final_score'], x['breed']))
+                
+                # 更新排名
+                for i, rec in enumerate(final_recommendations, 1):
+                    rec['rank'] = i
+
+                # 新增：保存到歷史記錄
+                history_results = [{
+                    'breed': rec['breed'],
+                    'rank': rec['rank'],
+                    'final_score': rec['final_score']
+                } for rec in final_recommendations[:10]]  # 只保存前10名
+
+                history_component.save_search(
+                    user_preferences=None,  # description搜尋不需要preferences
+                    results=history_results,
+                    search_type="description",
+                    description=description  # 用戶輸入的描述文字
+                )
+                        
+                # 驗證排序
+                print("\nFinal Rankings:")
+                for rec in final_recommendations:
+                    print(f"#{rec['rank']} {rec['breed']}")
+                    print(f"Base Score: {rec['base_score']:.4f}")
+                    print(f"Bonus Score: {rec['bonus_score']:.4f}")
+                    print(f"Final Score: {rec['final_score']:.4f}")
+                    print(f"Reason: {rec['match_reason']}\n")
+                
+                result = format_recommendation_html(final_recommendations)
+                return [gr.update(value=result), gr.update(visible=False)]
+                
+            except Exception as e:
+                error_msg = f"Error processing your description. Details: {str(e)}"
+                return [gr.update(value=error_msg), gr.update(visible=False)]
+                    
+        def show_loading():
+            return [gr.update(value=""), gr.update(visible=True)]
+
+
+        get_recommendations_btn.click(
+            fn=on_find_match_click,
+            inputs=[
+                living_space,
+                exercise_time,
+                grooming_commitment,
+                experience_level,
+                has_children,
+                noise_tolerance
+            ],
+            outputs=recommendation_output
+        )
+
+        description_search_btn.click(
+            fn=show_loading,  # 先顯示加載消息
+            outputs=[description_output, loading_msg]
+        ).then(  # 然後執行搜索
+            fn=on_description_search,
+            inputs=[description_input],
+            outputs=[description_output, loading_msg]
+        )
+
+    return {
+        'living_space': living_space,
+        'exercise_time': exercise_time,
+        'grooming_commitment': grooming_commitment,
+        'experience_level': experience_level,
+        'has_children': has_children,
+        'noise_tolerance': noise_tolerance,
+        'get_recommendations_btn': get_recommendations_btn,
+        'recommendation_output': recommendation_output,
+        'description_input': description_input,
+        'description_search_btn': description_search_btn,
+        'description_output': description_output
+    }

description_search_ui.py

@@ -0,0 +1,163 @@
+
+import gradio as gr
+
+def create_description_search_tab():
+    """創建描述搜尋頁面的UI程式碼"""
+    guide_html = """
+     <div class="breed-search-container">
+        <div class="description-guide">
+            <h2 class="guide-title" style="
+                background: linear-gradient(90deg, #4299e1, #48bb78);
+                -webkit-background-clip: text;
+                -webkit-text-fill-color: transparent;
+                font-weight: 600;
+                font-size: 1.8em;
+            ">🐾 Describe Your Ideal Dog</h2>
+            
+            <div class="guide-content">
+                <p class="intro-text" style="
+                    background: linear-gradient(90deg, #4299e1, #48bb78);
+                    -webkit-background-clip: text;
+                    -webkit-text-fill-color: transparent;
+                    font-weight: 600;
+                    font-size: 1.2em;
+                    margin-bottom: 20px;
+                ">Help us find your perfect companion! Please consider including the following details:</p>
+                
+                <div class="criteria-grid" style="
+                    background: linear-gradient(to right, rgba(66, 153, 225, 0.1), rgba(72, 187, 120, 0.1));
+                    border-radius: 10px;
+                    padding: 20px;
+                ">                
+                    <div class="criteria-item">
+                        <span class="icon">🏃</span>
+                        <div class="criteria-content">
+                            <h3>Activity Level</h3>
+                            <p>Low • Moderate • High • Very Active</p>
+                        </div>
+                    </div>
+                    
+                    <div class="criteria-item">
+                        <span class="icon">🏠</span>
+                        <div class="criteria-content">
+                            <h3>Living Environment</h3>
+                            <p>Apartment • House • Yard Space</p>
+                        </div>
+                    </div>
+                    
+                    <div class="criteria-item">
+                        <span class="icon">👨‍👩‍👧‍👦</span>
+                        <div class="criteria-content">
+                            <h3>Family Situation</h3>
+                            <p>Children • Other Pets • Single Adult</p>
+                        </div>
+                    </div>
+                    
+                    <div class="criteria-item">
+                        <span class="icon">✂️</span>
+                        <div class="criteria-content">
+                            <h3>Grooming Commitment</h3>
+                            <p>Low • Medium • High Maintenance</p>
+                        </div>
+                    </div>
+                    
+                    <div class="criteria-item">
+                        <span class="icon">🎭</span>
+                        <div class="criteria-content">
+                            <h3>Desired Personality</h3>
+                            <p>Friendly • Independent • Intelligent • Calm</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    """
+
+    # 增加 CSS 的樣式
+    css = """
+    <style>
+    .breed-search-container {
+        background: white;
+        border-radius: 12px;
+        padding: 24px;
+        margin-bottom: 20px;
+    }
+    .guide-title {
+        font-size: 1.8rem;
+        color: #2c3e50;
+        margin-bottom: 20px;
+        text-align: center;
+    }
+    .intro-text {
+        color: #666;
+        text-align: center;
+        margin-bottom: 24px;
+        font-size: 1.1rem;
+    }
+    .criteria-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+        gap: 20px;
+        margin-bottom: 24px;
+    }
+    .criteria-item {
+        display: flex;
+        align-items: flex-start;
+        padding: 16px;
+        background: #f8fafc;
+        border-radius: 8px;
+        transition: all 0.3s ease;
+    }
+    .criteria-item:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
+    }
+    .criteria-item .icon {
+        font-size: 24px;
+        margin-right: 12px;
+        margin-top: 3px;
+    }
+    .criteria-content h3 {
+        font-size: 1.1rem;
+        color: #2c3e50;
+        margin: 0 0 4px 0;
+    }
+    .criteria-content p {
+        color: #666;
+        margin: 0;
+        font-size: 0.95rem;
+    }
+    </style>
+    """
+
+    with gr.Column():
+        # 顯示指南和樣式
+        gr.HTML(css + guide_html)
+        
+        # 描述輸入區
+        description_input = gr.Textbox(
+            label="",
+            placeholder="Example: I'm looking for a medium-sized, friendly dog that's good with kids...",
+            lines=5
+        )
+        
+        # 搜索按鈕
+        search_button = gr.Button(
+            "Find My Perfect Match! 🔍",
+            variant="primary",
+            size="lg"
+        )
+
+        # 加載消息
+        loading_msg = gr.HTML("""
+            <div style='text-align: center; color: #666;'>
+                <p><b>Finding your perfect match...</b></p>
+                <p>Please wait 15-20 seconds while we analyze your preferences.</p>
+            </div>
+        """, visible=False)
+        
+        # 結果顯示區域
+        result_output = gr.HTML(label="Breed Recommendations")
+        
+        return description_input, search_button, result_output, loading_msg

history_manager.py

@@ -0,0 +1,96 @@
+
+from datetime import datetime
+import json
+import os
+import pytz
+import traceback
+
+class UserHistoryManager:
+    def __init__(self):
+        """初始化歷史紀錄管理器"""
+        self.history_file = "user_history.json"
+        print(f"Initializing UserHistoryManager with file: {os.path.abspath(self.history_file)}")
+        self._init_file()
+
+    def _init_file(self):
+        """初始化JSON檔案"""
+        try:
+            if not os.path.exists(self.history_file):
+                print(f"Creating new history file: {self.history_file}")
+                with open(self.history_file, 'w', encoding='utf-8') as f:
+                    json.dump([], f)
+            else:
+                print(f"History file exists: {self.history_file}")
+                # 驗證檔案內容
+                with open(self.history_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    print(f"Current history entries: {len(data)}")
+        except Exception as e:
+            print(f"Error in _init_file: {str(e)}")
+            print(traceback.format_exc())
+
+    def save_history(self, user_preferences: dict = None, results: list = None, search_type: str = "criteria", description: str = None) -> bool:
+        """
+        儲存搜尋歷史，支援兩種類型的搜尋
+        Args:
+            user_preferences: dict, 使用者偏好設定 (用於 criteria 搜尋)
+            results: list, 推薦結果
+            search_type: str, 搜尋類型 ("criteria" 或 "description")
+            description: str, 使用者輸入的描述 (用於 description 搜尋)
+        """
+        try:
+            taipei_tz = pytz.timezone('Asia/Taipei')
+            taipei_time = datetime.now(taipei_tz)
+            
+            history_entry = {
+                "timestamp": taipei_time.strftime("%Y-%m-%d %H:%M:%S"),
+                "search_type": search_type,
+                "results": results
+            }
+            
+            # 根據搜尋類型添加不同的資訊
+            if search_type == "criteria":
+                history_entry["preferences"] = user_preferences
+            else:  # description
+                history_entry["description"] = description
+                
+            with open(self.history_file, 'r', encoding='utf-8') as f:
+                history = json.load(f)
+                
+            history.append(history_entry)
+            if len(history) > 20:
+                history = history[-20:]
+                
+            with open(self.history_file, 'w', encoding='utf-8') as f:
+                json.dump(history, f, ensure_ascii=False, indent=2)
+                
+            return True
+        except Exception as e:
+            print(f"Error saving history: {str(e)}")
+            return False
+
+    def get_history(self) -> list:
+        """獲取搜尋歷史"""
+        try:
+            print("Attempting to read history")  # Debug
+            with open(self.history_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                print(f"Read {len(data)} history entries")  # Debug
+                return data if isinstance(data, list) else []
+        except Exception as e:
+            print(f"Error reading history: {str(e)}")
+            print(traceback.format_exc())
+            return []
+
+    def clear_all_history(self) -> bool:
+        """清除所有歷史紀錄"""
+        try:
+            print("Attempting to clear all history")  # Debug
+            with open(self.history_file, 'w', encoding='utf-8') as f:
+                json.dump([], f)
+            print("History cleared successfully")  # Debug
+            return True
+        except Exception as e:
+            print(f"Error clearing history: {str(e)}")
+            print(traceback.format_exc())
+            return False

search_history.py

@@ -0,0 +1,239 @@
+
+import gradio as gr
+import traceback
+from typing import Optional, Dict, List
+from history_manager import UserHistoryManager
+
+class SearchHistoryComponent:
+    def __init__(self):
+        """初始化搜索歷史組件"""
+        self.history_manager = UserHistoryManager()
+
+    def format_history_html(self, history_data: Optional[List[Dict]] = None) -> str:
+        try:
+            if history_data is None:
+                history_data = self.history_manager.get_history()
+
+            if not history_data:
+                return """
+                <div style='
+                    text-align: center;
+                    padding: 40px 20px;
+                    color: #666;
+                    background: linear-gradient(to right, rgba(66, 153, 225, 0.05), rgba(72, 187, 120, 0.05));
+                    border-radius: 10px;
+                    margin: 20px 0;
+                '>
+                    <p style='
+                        font-size: 1.1em;
+                        margin: 0;
+                        background: linear-gradient(90deg, #4299e1, #48bb78);
+                        -webkit-background-clip: text;
+                        -webkit-text-fill-color: transparent;
+                        font-weight: 600;
+                    '>
+                        No search history yet. Try making some breed recommendations!
+                    </p>
+                </div>
+                """
+
+            html = "<div class='history-container'>"
+
+            for entry in reversed(history_data):
+                timestamp = entry.get('timestamp', 'Unknown time')
+                search_type = entry.get('search_type', 'criteria')
+                results = entry.get('results', [])
+
+                # 根據搜尋類型使用不同的標題樣式
+                type_label = "Criteria History" if search_type == "criteria" else "Description History"
+                type_color = "#4299e1" if search_type == "criteria" else "#48bb78"  # 藍色vs綠色
+
+                html += f"""
+                <div class="history-entry">
+                    <div class="history-header" style="border-left: 4px solid {type_color}; padding-left: 10px;">
+                        <span class="timestamp">🕒 {timestamp}</span>
+                        <span class="search-type" style="color: {type_color}; font-weight: bold; margin-left: 10px;">
+                            {type_label}
+                        </span>
+                    </div>
+                """
+
+                if search_type == "criteria":
+                    # 原有的條件搜尋顯示邏輯
+                    prefs = entry.get('preferences', {})
+                    html += f"""
+                    <div class="params-list">
+                        <h4>Search Parameters:</h4>
+                        <ul>
+                            <li><span class="param-label">Living Space:</span> {prefs.get('living_space', 'N/A')}</li>
+                            <li><span class="param-label">Exercise Time:</span> {prefs.get('exercise_time', 'N/A')} minutes</li>
+                            <li><span class="param-label">Grooming:</span> {prefs.get('grooming_commitment', 'N/A')}</li>
+                            <li><span class="param-label">Experience:</span> {prefs.get('experience_level', 'N/A')}</li>
+                            <li><span class="param-label">Children at Home:</span> {"Yes" if prefs.get('has_children') else "No"}</li>
+                            <li><span class="param-label">Noise Tolerance:</span> {prefs.get('noise_tolerance', 'N/A')}</li>
+                        </ul>
+                    </div>
+                    """
+                else:
+                    # Description 搜尋的顯示邏輯
+                    description = entry.get('description', 'No description provided')
+                    html += f"""
+                    <div class="description-section">
+                        <h4>Search Description:</h4>
+                        <p class="user-description">{description}</p>
+                    </div>
+                    """
+
+                # 共用的結果顯示邏輯
+                html += """
+                <div class="results-list">
+                    <h4>Top 10 Breed Matches:</h4>
+                    <div class="breed-list">
+                """
+
+                if results:
+                    for i, result in enumerate(results[:10], 1):
+                        breed_name = result.get('breed', 'Unknown breed').replace('_', ' ')
+                        score = result.get('overall_score', result.get('final_score', 0))
+                        html += f"""
+                            <div class="breed-item">
+                                <div class="breed-info">
+                                    <span class="breed-rank">#{i}</span>
+                                    <span class="breed-name">{breed_name}</span>
+                                    <span class="breed-score">{score*100:.1f}%</span>
+                                </div>
+                            </div>
+                        """
+
+                html += """
+                        </div>
+                    </div>
+                </div>
+                """
+
+            html += "</div>"
+            return html
+
+        except Exception as e:
+            print(f"Error formatting history: {str(e)}")
+            print(traceback.format_exc())
+            return f"""
+            <div style='text-align: center; padding: 20px; color: #dc2626;'>
+                Error formatting history. Please try refreshing the page.
+                <br>Error details: {str(e)}
+            </div>
+        """
+
+    def clear_history(self) -> str:
+        """清除所有搜尋歷史"""
+        try:
+            success = self.history_manager.clear_all_history()
+            print(f"Clear history result: {success}")
+            return self.format_history_html()
+        except Exception as e:
+            print(f"Error in clear_history: {str(e)}")
+            print(traceback.format_exc())
+            return "Error clearing history"
+
+    def refresh_history(self) -> str:
+        """刷新歷史記錄顯示"""
+        try:
+            return self.format_history_html()
+        except Exception as e:
+            print(f"Error in refresh_history: {str(e)}")
+            return "Error refreshing history"
+
+    def save_search(self, user_preferences: Optional[dict] = None, 
+                     results: list = None,
+                     search_type: str = "criteria",
+                     description: str = None) -> bool:
+        """保存搜索結果
+        Args:
+            user_preferences: 使用者偏好設定 (僅用於criteria搜尋)
+            results: 推薦結果列表
+            search_type: 搜尋類型 ("criteria" 或 "description")
+            description: 使用者輸入的描述 (僅用於description搜尋)
+        """
+        return self.history_manager.save_history(
+            user_preferences=user_preferences,
+            results=results,
+            search_type=search_type,
+            description=description
+        )
+
+def create_history_component():
+    """只創建實例"""
+    return SearchHistoryComponent()
+
+def create_history_tab(history_component: SearchHistoryComponent):
+    """創建歷史紀錄的頁面
+
+    Args:
+        history_component: 已创建的历史组件实例
+    """
+    with gr.TabItem("Recommendation Search History"):
+        gr.HTML("""
+            <div style='text-align: center; padding: 20px;'>
+                <h3 style='
+                    color: #2D3748;
+                    margin-bottom: 10px;
+                    font-size: 1.5em;
+                    background: linear-gradient(90deg, #4299e1, #48bb78);
+                    -webkit-background-clip: text;
+                    -webkit-text-fill-color: transparent;
+                    font-weight: 600;
+                '>Search History</h3>
+                <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;
+                    '>
+                        View your previous breed recommendations and search preferences
+                    </p>
+                </div>
+            </div>
+        """)
+
+        with gr.Row():
+            with gr.Column(scale=4):
+                history_display = gr.HTML()
+
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        clear_history_btn = gr.Button(
+                            "🗑️ Clear History",
+                            variant="secondary",
+                            size="sm"
+                        )
+                    with gr.Column(scale=1):
+                        refresh_btn = gr.Button(
+                            "🔄 Refresh",
+                            variant="secondary",
+                            size="sm"
+                        )
+
+                history_display.value = history_component.format_history_html()
+
+                clear_history_btn.click(
+                    fn=history_component.clear_history,
+                    outputs=[history_display],
+                    api_name="clear_history"
+                )
+
+                refresh_btn.click(
+                    fn=history_component.refresh_history,
+                    outputs=[history_display],
+                    api_name="refresh_history"
+                )